stripe

package module
v16.2.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 7, 2016 License: MIT Imports: 19 Imported by: 0

README

Go Stripe GoDoc Build Status

Summary

The official Stripe Go client library.

Versioning

Each revision of the binding is tagged and the version is updated accordingly.

Given Go's lack of built-in versioning, it is highly recommended you use a package management tool in order to ensure a newer version of the binding does not affect backwards compatibility.

To see the list of past versions, run git tag. To manually get an older version of the client, clone this repo, checkout the specific tag and build the library:

git clone https://github.com/stripe/stripe-go.git
cd stripe-go
git checkout api_version_tag
make build

For more details on changes between versions, see the binding changelog and API changelog.

Installation

go get github.com/stripe/stripe-go

Documentation

For a comprehensive list of examples, check out the API documentation.

For details on all the functionality in this library, see the GoDoc documentation.

Below are a few simple examples:

Customers
params := &stripe.CustomerParams{
	Balance: -123,
	Desc:  "Stripe Developer",
	Email: "gostripe@stripe.com",
}
params.SetSource(&stripe.CardParams{
	Name:   "Go Stripe",
	Number: "378282246310005",
	Month:  "06",
	Year:   "15",
})

customer, err := customer.New(params)
Charges
params := &stripe.ChargeListParams{Customer: customer.ID}
params.Filters.AddFilter("include[]", "", "total_count")

// set this so you can easily retry your request in case of a timeout
params.Params.IdempotencyKey = stripe.NewIdempotencyKey()

i := charge.List(params)
for i.Next() {
	charge := i.Charge()
}

if err := i.Err(); err != nil {
	// handle
}
Events
i := event.List(nil)
for i.Next() {
	e := i.Event()

	// access event data via e.GetObjValue("resource_name_based_on_type", "resource_property_name")
	// alternatively you can access values via e.Data.Obj["resource_name_based_on_type"].(map[string]interface{})["resource_property_name"]

	// access previous attributes via e.GetPrevValue("resource_name_based_on_type", "resource_property_name")
	// alternatively you can access values via e.Data.Prev["resource_name_based_on_type"].(map[string]interface{})["resource_property_name"]
}

Alternatively, you can use the even.Data.Raw property to unmarshal to the appropriate struct.

Authentication with Connect

There are two ways of authenticating requests when performing actions on behalf of a connected account, one that uses the Stripe-Account header containing an account's ID, and one that uses the account's keys. Usually the former is the recommended approach. See the documentation for more information.

To use the Stripe-Account approach, pass the StripeAccount field to a ListParams or Params class. For example:

// For a list request
listParams := &stripe.ChargeListParams{StripeAccount: merchantID}

// For any other kind of request
params := &stripe.CustomerParams{StripeAccount: merchantID}

To use a key, pass it to API's Init function:


import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

stripe := &client.API{}
stripe.Init("access_token", nil)
Google AppEngine

If you're running the client in a Google AppEngine environment, you'll need to create a per-request Stripe client since the http.DefaultClient is not available. Here's a sample handler:

import (
	"fmt"
	"net/http"

	"google.golang.org/appengine"
	"google.golang.org/appengine/urlfetch"

	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

func handler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	httpClient := urlfetch.Client(c)

	sc := client.New("sk_live_key", stripe.NewBackends(httpClient))

	fmt.Fprintf(w, "Ready to make calls to the Stripe API")
}

Usage

While some resources may contain more/less APIs, the following pattern is applied throughout the library for a given $resource$:

Without a Client

If you're only dealing with a single key, you can simply import the packages required for the resources you're interacting with without the need to create a client.

import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/$resource$"
)

// Setup
stripe.Key = "sk_key"

stripe.SetBackend("api", backend) // optional, useful for mocking

// Create
$resource$, err := $resource$.New(stripe.$Resource$Params)

// Get
$resource$, err := $resource$.Get(id, stripe.$Resource$Params)

// Update
$resource$, err := $resource$.Update(stripe.$Resource$Params)

// Delete
err := $resource$.Del(id)

// List
i := $resource$.List(stripe.$Resource$ListParams)
for i.Next() {
	$resource$ := i.$Resource$()
}

if err := i.Err(); err != nil {
	// handle
}
With a Client

If you're dealing with multiple keys, it is recommended you use client.API. This allows you to create as many clients as needed, each with their own individual key.

import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

// Setup
sc := &client.API{}
sc.Init("sk_key", nil) // the second parameter overrides the backends used if needed for mocking

// Create
$resource$, err := sc.$Resource$s.New(stripe.$Resource$Params)

// Get
$resource$, err := sc.$Resource$s.Get(id, stripe.$Resource$Params)

// Update
$resource$, err := sc.$Resource$s.Update(stripe.$Resource$Params)

// Delete
err := sc.$Resource$s.Del(id)

// List
i := sc.$Resource$s.List(stripe.$Resource$ListParams)
for i.Next() {
	resource := i.$Resource$()
}

if err := i.Err(); err != nil {
	// handle
}

Development

Pull requests from the community are welcome. If you submit one, please keep the following guidelines in mind:

  1. Code must be go fmt compliant.
  2. All types, structs and funcs should be documented.
  3. Ensure that make test succeeds.

Test

For running additional tests, follow the steps below:

Set the STRIPE_KEY environment variable to match your test private key, then run make test:

STRIPE_KEY=YOUR_API_KEY make test

Or to run tests for a particular subpackage:

STRIPE_KEY=YOUR_API_KEY go test ./invoice

Or to run a particular test (it's worth noting however that Go will report a success even if the referenced test doesn't exist):

STRIPE_KEY=YOUR_API_KEY go test -run "TestAllInvoicesScenarios" ./invoice

For any requests, bug or comments, please open an issue or submit a pull request.

Documentation

Overview

Package stripe provides the binding for Stripe REST APIs.

Index

Examples

Constants

View Source 
const (
	// Individual is a constant value representing an individual legal entity
	// type.
	Individual LegalEntityType = "individual"

	// Company is a constant value representing a company legal entity type.
	Company LegalEntityType = "company"

	// IdentityVerificationPending is a constant value indicating that identity
	// verification status is pending.
	IdentityVerificationPending IdentityVerificationStatus = "pending"

	// IdentityVerificationVerified is a constant value indicating that
	// identity verification status is verified.
	IdentityVerificationVerified IdentityVerificationStatus = "verified"

	// IdentityVerificationUnverified is a constant value indicating that
	// identity verification status is unverified.
	IdentityVerificationUnverified IdentityVerificationStatus = "unverified"

	// Manual is a constant value representing a manual payout interval.
	Manual Interval = "manual"

	// Day is a constant value representing a daily payout interval.
	Day Interval = "daily"

	// Week is a constant value representing a weekly payout interval.
	Week Interval = "weekly"

	// Month is a constant value representing a monthly payout interval.
	Month Interval = "monthly"
)
View Source 
const (
	ErrorTypeAPI            ErrorType = "api_error"
	ErrorTypeAPIConnection  ErrorType = "api_connection_error"
	ErrorTypeAuthentication ErrorType = "authentication_error"
	ErrorTypeCard           ErrorType = "card_error"
	ErrorTypeInvalidRequest ErrorType = "invalid_request_error"
	ErrorTypeRateLimit      ErrorType = "rate_limit_error"

	IncorrectNum  ErrorCode = "incorrect_number"
	InvalidNum    ErrorCode = "invalid_number"
	InvalidExpM   ErrorCode = "invalid_expiry_month"
	InvalidExpY   ErrorCode = "invalid_expiry_year"
	InvalidCvc    ErrorCode = "invalid_cvc"
	ExpiredCard   ErrorCode = "expired_card"
	IncorrectCvc  ErrorCode = "incorrect_cvc"
	IncorrectZip  ErrorCode = "incorrect_zip"
	CardDeclined  ErrorCode = "card_declined"
	Missing       ErrorCode = "missing"
	ProcessingErr ErrorCode = "processing_error"
	RateLimit     ErrorCode = "rate_limit"

	APIErr         ErrorType = ErrorTypeAPI
	CardErr        ErrorType = ErrorTypeCard
	InvalidRequest ErrorType = ErrorTypeInvalidRequest
)
View Source 
const (
	// APIBackend is a constant representing the API service backend.
	APIBackend SupportedBackend = "api"

	// APIURL is the URL of the API service backend.
	APIURL string = "https://api.stripe.com/v1"

	// UploadsBackend is a constant representing the uploads service backend.
	UploadsBackend SupportedBackend = "uploads"

	// UploadsURL is the URL of the uploads service backend.
	UploadsURL string = "https://uploads.stripe.com/v1"
)
View Source 
const TotalBackends = 2

TotalBackends is the total number of Stripe API endpoints supported by the binding.

Variables

View Source 
var Key string

Key is the Stripe API key used globally in the binding.

View Source 
var LogLevel = 2

LogLevel is the logging level for this library. 0: no logging 1: errors only 2: errors + informational (default) 3: errors + informational + debug

View Source 
var Logger *log.Logger

Logger controls how stripe performs logging at a package level. It is useful to customise if you need it prefixed for your application to meet other requirements

Functions

func NewIdempotencyKey 

func NewIdempotencyKey() string

NewIdempotencyKey generates a new idempotency key that can be used on a request.

func SetBackend 

func SetBackend(backend SupportedBackend, b Backend)

SetBackend sets the backend used in the binding.

func SetHTTPClient 

func SetHTTPClient(client *http.Client)

SetHTTPClient overrides the default HTTP client. This is useful if you're running in a Google AppEngine environment where the http.DefaultClient is not available.

Types

type APIConnectionError 

type APIConnectionError struct {
	// contains filtered or unexported fields
}

APIConnectionError is a failure to connect to the Stripe API.

func (*APIConnectionError) Error 

func (e *APIConnectionError) Error() string

Error serializes the error object to JSON and returns it as a string.

type APIError 

type APIError struct {
	// contains filtered or unexported fields
}

APIError is a catch all for any errors not covered by other types (and should be extremely uncommon).

func (*APIError) Error 

func (e *APIError) Error() string

Error serializes the error object to JSON and returns it as a string.

type Account 

type Account struct {
	ID                   string               `json:"id"`
	ChargesEnabled       bool                 `json:"charges_enabled"`
	Country              string               `json:"country"`
	DefaultCurrency      string               `json:"default_currency"`
	DetailsSubmitted     bool                 `json:"details_submitted"`
	TransfersEnabled     bool                 `json:"transfers_enabled"`
	Name                 string               `json:"display_name"`
	Email                string               `json:"email"`
	ExternalAccounts     *ExternalAccountList `json:"external_accounts"`
	Statement            string               `json:"statement_descriptor"`
	Timezone             string               `json:"timezone"`
	BusinessName         string               `json:"business_name"`
	BusinessPrimaryColor string               `json:"business_primary_color"`
	BusinessUrl          string               `json:"business_url"`
	SupportPhone         string               `json:"support_phone"`
	SupportEmail         string               `json:"support_email"`
	SupportUrl           string               `json:"support_url"`
	ProductDesc          string               `json:"product_description"`
	Managed              bool                 `json:"managed"`
	DebitNegativeBal     bool                 `json:"debit_negative_balances"`
	Keys                 *struct {
		Secret  string `json:"secret"`
		Publish string `json:"publishable"`
	} `json:"keys"`
	Verification *struct {
		Fields         []string `json:"fields_needed"`
		Due            *int64   `json:"due_by"`
		DisabledReason string   `json:"disabled_reason"`
	} `json:"verification"`
	LegalEntity      *LegalEntity      `json:"legal_entity"`
	TransferSchedule *TransferSchedule `json:"transfer_schedule"`
	TOSAcceptance    *struct {
		Date      int64  `json:"date"`
		IP        string `json:"ip"`
		UserAgent string `json:"user_agent"`
	} `json:"tos_acceptance"`
	SupportAddress *Address `json:"support_address"`
	Deleted        bool     `json:"deleted"`
}

Account is the resource representing your Stripe account. For more details see https://stripe.com/docs/api/#account.

func (*Account) UnmarshalJSON 

func (a *Account) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an Account. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type AccountExternalAccountParams 

type AccountExternalAccountParams struct {
	Params
	Account, Country, Currency, Routing, Token string
}

AccountExternalAccountParams are the parameters allowed to reference an external account when creating an account. It should either have Token set or everything else.

type AccountList 

type AccountList struct {
	ListMeta
	Values []*Account `json:"data"`
}

AccountList is a list of accounts as returned from a list endpoint.

type AccountListParams 

type AccountListParams struct {
	ListParams
}

AccountListParams are the parameters allowed during account listing.

type AccountParams 

type AccountParams struct {
	Params
	Country, Email, DefaultCurrency, Statement, BusinessName, BusinessUrl,
	BusinessPrimaryColor, SupportPhone, SupportEmail, SupportUrl string
	ExternalAccount           *AccountExternalAccountParams
	LegalEntity               *LegalEntity
	TransferSchedule          *TransferScheduleParams
	Managed, DebitNegativeBal bool
	TOSAcceptance             *TOSAcceptanceParams
}

AccountParams are the parameters allowed during account creation/updates.

type AccountRejectParams 

type AccountRejectParams struct {
	Reason string `json:"reason"`
}

AccountRejectParams is the structure for the Reject function.

type AccountType 

type AccountType string

AccountType is the type of an external account. 

const (
	// AccountTypeBankAccount is a constant value representing an external
	// account which is a bank account.
	AccountTypeBankAccount AccountType = "bank_account"

	// AccountTypeCard is a constant value representing an external account
	// which is a card.
	AccountTypeCard AccountType = "card"
)

type Address 

type Address struct {
	Line1   string `json:"line1"`
	Line2   string `json:"line2"`
	City    string `json:"city"`
	State   string `json:"state"`
	Zip     string `json:"postal_code"`
	Country string `json:"country"`
}

Address is the structure for an account address.

type AddressParams 

type AddressParams struct {
	Line1      string
	Line2      string
	City       string
	State      string
	PostalCode string
	Country    string
}

type Amount 

type Amount struct {
	Value    int64    `json:"amount"`
	Currency Currency `json:"currency"`
}

Amount is a structure wrapping an amount value and its currency.

type AuthenticationError 

type AuthenticationError struct {
	// contains filtered or unexported fields
}

AuthenticationError is a failure to properly authenticate during a request.

func (*AuthenticationError) Error 

func (e *AuthenticationError) Error() string

Error serializes the error object to JSON and returns it as a string.

type Backend 

type Backend interface {
	Call(method, path, key string, body *RequestValues, params *Params, v interface{}) error
	CallMultipart(method, path, key, boundary string, body io.Reader, params *Params, v interface{}) error
}

Backend is an interface for making calls against a Stripe service. This interface exists to enable mocking for during testing if needed.

func GetBackend 

func GetBackend(backend SupportedBackend) Backend

GetBackend returns the currently used backend in the binding.

type BackendConfiguration 

type BackendConfiguration struct {
	Type       SupportedBackend
	URL        string
	HTTPClient *http.Client
}

BackendConfiguration is the internal implementation for making HTTP calls to Stripe.

func (BackendConfiguration) Call 

func (s BackendConfiguration) Call(method, path, key string, form *RequestValues, params *Params, v interface{}) error

Call is the Backend.Call implementation for invoking Stripe APIs.

func (BackendConfiguration) CallMultipart 

func (s BackendConfiguration) CallMultipart(method, path, key, boundary string, body io.Reader, params *Params, v interface{}) error

CallMultipart is the Backend.CallMultipart implementation for invoking Stripe APIs.

func (*BackendConfiguration) Do 

func (s *BackendConfiguration) Do(req *http.Request, v interface{}) error

Do is used by Call to execute an API request and parse the response. It uses the backend's HTTP client to execute the request and unmarshals the response into v. It also handles unmarshaling errors returned by the API.

func (*BackendConfiguration) NewRequest 

func (s *BackendConfiguration) NewRequest(method, path, key, contentType string, body io.Reader, params *Params) (*http.Request, error)

NewRequest is used by Call to generate an http.Request. It handles encoding parameters and attaching the appropriate headers.

func (*BackendConfiguration) ResponseToError 

func (s *BackendConfiguration) ResponseToError(res *http.Response, resBody []byte) error

type Backends 

type Backends struct {
	API, Uploads Backend
}

Backends are the currently supported endpoints.

func NewBackends 

func NewBackends(httpClient *http.Client) *Backends

NewBackends creates a new set of backends with the given HTTP client. You should only need to use this for testing purposes or on App Engine.

type Balance 

type Balance struct {
	// Live indicates the live mode.
	Live      bool     `json:"livemode"`
	Available []Amount `json:"available"`
	Pending   []Amount `json:"pending"`
}

Balance is the resource representing your Stripe balance. For more details see https://stripe.com/docs/api/#balance.

type BalanceParams 

type BalanceParams struct {
	Params
}

BalanceParams is the set of parameters that can be used when retrieving a balance. For more details see https://stripe.com/docs/api#balance.

type BankAccount 

type BankAccount struct {
	ID                string            `json:"id"`
	Name              string            `json:"bank_name"`
	AccountHolderName string            `json:"account_holder_name"`
	AccountHolderType string            `json:"account_holder_type"`
	Country           string            `json:"country"`
	Currency          Currency          `json:"currency"`
	Default           bool              `json:"default_for_currency"`
	LastFour          string            `json:"last4"`
	Fingerprint       string            `json:"fingerprint"`
	Status            BankAccountStatus `json:"status"`
	Routing           string            `json:"routing_number"`
	Deleted           bool              `json:"deleted"`
	Customer          *Customer         `json:"customer"`
	Meta              map[string]string `json:"metadata"`
}

BankAccount represents a Stripe bank account.

func (*BankAccount) Display 

func (b *BankAccount) Display() string

Display implements Displayer.Display.

func (*BankAccount) UnmarshalJSON 

func (b *BankAccount) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a BankAccount. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type BankAccountList 

type BankAccountList struct {
	ListMeta
	Values []*BankAccount `json:"data"`
}

BankAccountList is a list object for bank accounts.

type BankAccountListParams 

type BankAccountListParams struct {
	ListParams
	AccountID string
}

BankAccountListParams is the set of parameters that can be used when listing bank accounts.

type BankAccountParams 

type BankAccountParams struct {
	Params

	// The identifier of the parent account under which bank accounts are
	// nested.
	AccountID string

	// A token referencing an external account like one returned from
	// Stripe.js.
	Token string

	// Information on an external account to reference. Only used if `Token`
	// is not provided.
	Account, AccountHolderName, AccountHolderType, Country, Currency, Routing string

	Default  bool
	Customer string
}

BankAccountParams is the set of parameters that can be used when creating or updating a bank account.

func (*BankAccountParams) AppendDetails 

func (b *BankAccountParams) AppendDetails(values *RequestValues)

AppendDetails adds the bank account's details to the query string values.

type BankAccountStatus 

type BankAccountStatus string

BankAccountStatus is the list of allowed values for the bank account's status. Allowed values are "new", "verified", "validated", "errored".

type BitcoinReceiver 

type BitcoinReceiver struct {
	ID                    string                  `json:"id"`
	Created               int64                   `json:"created"`
	Currency              Currency                `json:"currency"`
	Amount                uint64                  `json:"amount"`
	AmountReceived        uint64                  `json:"amount_received"`
	BitcoinAmount         uint64                  `json:"bitcoin_amount"`
	BitcoinAmountReceived uint64                  `json:"bitcoin_amount_received"`
	Filled                bool                    `json:"filled"`
	Active                bool                    `json:"active"`
	RejectTransactions    bool                    `json:"reject_transactions"`
	Desc                  string                  `json:"description"`
	InboundAddress        string                  `json:"inbound_address"`
	RefundAddress         string                  `json:"refund_address"`
	BitcoinUri            string                  `json:"bitcoin_uri"`
	Meta                  map[string]string       `json:"metadata"`
	Email                 string                  `json:"email"`
	Payment               string                  `json:"payment"`
	Customer              string                  `json:"customer"`
	Transactions          *BitcoinTransactionList `json:"transactions"`
}

BitcoinReceiver is the resource representing a Stripe bitcoin receiver. For more details see https://stripe.com/docs/api/#bitcoin_receivers

func (*BitcoinReceiver) Display 

func (br *BitcoinReceiver) Display() string

Display human readable representation of a BitcoinReceiver.

func (*BitcoinReceiver) UnmarshalJSON 

func (br *BitcoinReceiver) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a BitcoinReceiver. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type BitcoinReceiverList 

type BitcoinReceiverList struct {
	ListMeta
	Values []*BitcoinReceiver `json:"data"`
}

BitcoinReceiverList is a list of bitcoin receivers as retrieved from a list endpoint.

type BitcoinReceiverListParams 

type BitcoinReceiverListParams struct {
	ListParams
	NotFilled, NotActive, Uncaptured bool
}

BitcoinReceiverListParams is the set of parameters that can be used when listing BitcoinReceivers. For more details see https://stripe.com/docs/api/#list_bitcoin_receivers.

type BitcoinReceiverParams 

type BitcoinReceiverParams struct {
	Params
	Amount      uint64
	Currency    Currency
	Desc, Email string
}

BitcoinReceiverParams is the set of parameters that can be used when creating a BitcoinReceiver. For more details see https://stripe.com/docs/api/#create_bitcoin_receiver.

type BitcoinReceiverUpdateParams 

type BitcoinReceiverUpdateParams struct {
	Params
	Desc, Email, RefundAddr string
}

BitcoinReceiverUpdateParams is the set of parameters that can be used when updating a BitcoinReceiver. For more details see https://stripe.com/docs/api/#update_bitcoin_receiver.

type BitcoinTransaction 

type BitcoinTransaction struct {
	ID            string   `json:"id"`
	Created       int64    `json:"created"`
	Amount        uint64   `json:"amount"`
	Currency      Currency `json:"currency"`
	BitcoinAmount uint64   `json:"bitcoin_amount"`
	Receiver      string   `json:"receiver"`
	Customer      string   `json:"customer"`
}

BitcoinTransaction is the resource representing a Stripe bitcoin transaction. For more details see https://stripe.com/docs/api/#bitcoin_receivers

func (*BitcoinTransaction) UnmarshalJSON 

func (bt *BitcoinTransaction) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a BitcoinTransaction. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type BitcoinTransactionList 

type BitcoinTransactionList struct {
	ListMeta
	Values []*BitcoinTransaction `json:"data"`
}

BitcoinTransactionList is a list object for BitcoinTransactions. It is a child object of BitcoinRecievers For more details see https://stripe.com/docs/api/#retrieve_bitcoin_receiver

type BitcoinTransactionListParams 

type BitcoinTransactionListParams struct {
	ListParams
	Receiver, Customer string
}

BitcoinTransactionListParams is the set of parameters that can be used when listing BitcoinTransactions.

type CaptureParams 

type CaptureParams struct {
	Params
	Amount, Fee uint64
	Email       string
}

CaptureParams is the set of parameters that can be used when capturing a charge. For more details see https://stripe.com/docs/api#charge_capture.

type Card 

type Card struct {
	ID                 string             `json:"id"`
	Month              uint8              `json:"exp_month"`
	Year               uint16             `json:"exp_year"`
	Fingerprint        string             `json:"fingerprint"`
	Funding            CardFunding        `json:"funding"`
	LastFour           string             `json:"last4"`
	Brand              CardBrand          `json:"brand"`
	Currency           Currency           `json:"currency"`
	Default            bool               `json:"default_for_currency"`
	City               string             `json:"address_city"`
	Country            string             `json:"address_country"`
	Address1           string             `json:"address_line1"`
	Address1Check      Verification       `json:"address_line1_check"`
	Address2           string             `json:"address_line2"`
	State              string             `json:"address_state"`
	Zip                string             `json:"address_zip"`
	ZipCheck           Verification       `json:"address_zip_check"`
	CardCountry        string             `json:"country"`
	Customer           *Customer          `json:"customer"`
	CVCCheck           Verification       `json:"cvc_check"`
	Meta               map[string]string  `json:"metadata"`
	Name               string             `json:"name"`
	Recipient          *Recipient         `json:"recipient"`
	DynLastFour        string             `json:"dynamic_last4"`
	Deleted            bool               `json:"deleted"`
	TokenizationMethod TokenizationMethod `json:"tokenization_method"`

	// Description is a succinct summary of the card's information.
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	Description string `json:"description"`

	// IIN is the card's "Issuer Identification Number".
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	IIN string `json:"iin"`

	// Issuer is a bank or financial institution that provides the card.
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	Issuer string `json:"issuer"`
}

Card is the resource representing a Stripe credit/debit card. For more details see https://stripe.com/docs/api#cards.

func (*Card) Display 

func (c *Card) Display() string

Display human readable representation of a Card.

func (*Card) UnmarshalJSON 

func (c *Card) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Card. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type CardBrand 

type CardBrand string

CardBrand is the list of allowed values for the card's brand. Allowed values are "Unknown", "Visa", "American Express", "MasterCard", "Discover" "JCB", "Diners Club".

type CardError 

type CardError struct {
	DeclineCode string `json:"decline_code,omitempty"`
	// contains filtered or unexported fields
}

CardError are the most common type of error you should expect to handle. They result when the user enters a card that can't be charged for some reason.

func (*CardError) Error 

func (e *CardError) Error() string

Error serializes the error object to JSON and returns it as a string.

type CardFunding 

type CardFunding string

CardFunding is the list of allowed values for the card's funding. Allowed values are "credit", "debit", "prepaid", "unknown".

type CardList 

type CardList struct {
	ListMeta
	Values []*Card `json:"data"`
}

CardList is a list object for cards.

type CardListParams 

type CardListParams struct {
	ListParams
	Account, Customer, Recipient string
}

CardListParams is the set of parameters that can be used when listing cards. For more details see https://stripe.com/docs/api#list_cards.

type CardParams 

type CardParams struct {
	Params
	Token                                         string
	Default                                       bool
	Account, Customer, Recipient                  string
	Name, Number, Month, Year, CVC, Currency      string
	Address1, Address2, City, State, Zip, Country string
}

CardParams is the set of parameters that can be used when creating or updating a card. For more details see https://stripe.com/docs/api#create_card and https://stripe.com/docs/api#update_card.

func (*CardParams) AppendDetails 

func (c *CardParams) AppendDetails(values *RequestValues, creating bool)

AppendDetails adds the card's details to the query string values. When creating a new card, the parameters are passed as a dictionary, but on updates they are simply the parameter name.

type Charge 

type Charge struct {
	Amount         uint64            `json:"amount"`
	AmountRefunded uint64            `json:"amount_refunded"`
	Captured       bool              `json:"captured"`
	Created        int64             `json:"created"`
	Currency       Currency          `json:"currency"`
	Customer       *Customer         `json:"customer"`
	Desc           string            `json:"description"`
	Dest           *Account          `json:"destination"`
	Dispute        *Dispute          `json:"dispute"`
	Email          string            `json:"receipt_email"`
	FailCode       string            `json:"failure_code"`
	FailMsg        string            `json:"failure_message"`
	Fee            *Fee              `json:"application_fee"`
	FraudDetails   *FraudDetails     `json:"fraud_details"`
	ID             string            `json:"id"`
	Invoice        *Invoice          `json:"invoice"`
	Live           bool              `json:"livemode"`
	Meta           map[string]string `json:"metadata"`
	Outcome        *ChargeOutcome    `json:"outcome"`
	Paid           bool              `json:"paid"`
	Refunded       bool              `json:"refunded"`
	Refunds        *RefundList       `json:"refunds"`
	Shipping       *ShippingDetails  `json:"shipping"`
	Source         *PaymentSource    `json:"source"`
	SourceTransfer *Transfer         `json:"source_transfer"`
	Statement      string            `json:"statement_descriptor"`
	Status         string            `json:"status"`
	Transfer       *Transfer         `json:"transfer"`
	Tx             *Transaction      `json:"balance_transaction"`
}

Charge is the resource representing a Stripe charge. For more details see https://stripe.com/docs/api#charges.

Example (Get) 
package main

import (
	"log"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/charge"
)

func main() {
	stripe.Key = "sk_key"

	params := &stripe.ChargeParams{}
	params.Expand("customer")
	params.Expand("balance_transaction")

	ch, err := charge.Get("ch_example_id", params)

	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", ch.ID)
}

Output:
Example (New) 
package main

import (
	"log"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/charge"
	"github.com/stripe/stripe-go/currency"
)

func main() {
	stripe.Key = "sk_key"

	params := &stripe.ChargeParams{
		Amount:   1000,
		Currency: currency.USD,
	}
	params.SetSource(&stripe.CardParams{
		Name:   "Go Stripe",
		Number: "4242424242424242",
		Month:  "10",
		Year:   "20",
	})
	params.AddMeta("key", "value")

	ch, err := charge.New(params)

	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", ch.ID)
}

Output:

func (*Charge) UnmarshalJSON 

func (c *Charge) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Charge. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type ChargeList 

type ChargeList struct {
	ListMeta
	Values []*Charge `json:"data"`
}

ChargeList is a list of charges as retrieved from a list endpoint.

type ChargeListParams 

type ChargeListParams struct {
	ListParams
	Created  int64
	Customer string
}

ChargeListParams is the set of parameters that can be used when listing charges. For more details see https://stripe.com/docs/api#list_charges.

type ChargeOutcome 

type ChargeOutcome struct {
	NetworkStatus string `json:"network_status"`
	Reason        string `json:"reason"`
	SellerMessage string `json:"seller_message"`
	Type          string `json:"type"`
}

Outcome is the charge's outcome that details whether a payment was accepted and why.

type ChargeParams 

type ChargeParams struct {
	Params
	Amount                       uint64
	Currency                     Currency
	Customer, Token              string
	Desc, Statement, Email, Dest string
	NoCapture                    bool
	Fee                          uint64
	Fraud                        FraudReport
	Source                       *SourceParams
	Shipping                     *ShippingDetails
}

ChargeParams is the set of parameters that can be used when creating or updating a charge. For more details see https://stripe.com/docs/api#create_charge and https://stripe.com/docs/api#update_charge.

func (*ChargeParams) SetSource 

func (cp *ChargeParams) SetSource(sp interface{}) error

SetSource adds valid sources to a ChargeParams object, returning an error for unsupported sources.

type Country 

type Country string

Country is the list of supported countries

type CountrySpec 

type CountrySpec struct {
	ID                             string                                     `json:"id"`
	DefaultCurrency                Currency                                   `json:"default_currency"`
	SupportedBankAccountCurrencies map[Country][]Currency                     `json:"supported_bank_account_currencies"`
	SupportedPaymentCurrencies     []Currency                                 `json:"supported_payment_currencies"`
	SupportedPaymentMethods        []string                                   `json:"supported_payment_methods"`
	VerificationFields             map[LegalEntityType]VerificationFieldsList `json:"verification_fields"`
}

CountrySpec is the resource representing the rules required for a Stripe account. For more details see https://stripe.com/docs/api/#country_specs.

type CountrySpecList 

type CountrySpecList struct {
	ListMeta
	Values []*CountrySpec `json:"data"`
}

CountrySpecList is a list of country specs as retrieved from a list endpoint.

type CountrySpecListParams 

type CountrySpecListParams struct {
	ListParams
}

CountrySpecListParams are the parameters allowed during CountrySpec listing.

type Coupon 

type Coupon struct {
	ID             string            `json:"id"`
	Live           bool              `json:"livemode"`
	Created        int64             `json:"created"`
	Duration       CouponDuration    `json:"duration"`
	Amount         uint64            `json:"amount_off"`
	Currency       Currency          `json:"currency"`
	DurationPeriod uint64            `json:"duration_in_months"`
	Redemptions    uint64            `json:"max_redemptions"`
	Meta           map[string]string `json:"metadata"`
	Percent        uint64            `json:"percent_off"`
	RedeemBy       int64             `json:"redeem_by"`
	Redeemed       uint64            `json:"times_redeemed"`
	Valid          bool              `json:"valid"`
	Deleted        bool              `json:"deleted"`
}

Coupon is the resource representing a Stripe coupon. For more details see https://stripe.com/docs/api#coupons.

func (*Coupon) UnmarshalJSON 

func (c *Coupon) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Coupon. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type CouponDuration 

type CouponDuration string

CouponDuration is the list of allowed values for the coupon's duration. Allowed values are "forever", "once", "repeating".

type CouponList 

type CouponList struct {
	ListMeta
	Values []*Coupon `json:"data"`
}

CouponList is a list of coupons as retrieved from a list endpoint.

type CouponListParams 

type CouponListParams struct {
	ListParams
}

CouponListParams is the set of parameters that can be used when listing coupons. For more detail see https://stripe.com/docs/api#list_coupons.

type CouponParams 

type CouponParams struct {
	Params
	Duration                                     CouponDuration
	ID                                           string
	Currency                                     Currency
	Amount, Percent, DurationPeriod, Redemptions uint64
	RedeemBy                                     int64
}

CouponParams is the set of parameters that can be used when creating a coupon. For more details see https://stripe.com/docs/api#create_coupon.

type Currency 

type Currency string

Currency is the list of supported currencies. For more details see https://support.stripe.com/questions/which-currencies-does-stripe-support.

type Customer 

type Customer struct {
	ID            string                   `json:"id"`
	Live          bool                     `json:"livemode"`
	Sources       *SourceList              `json:"sources"`
	Created       int64                    `json:"created"`
	Balance       int64                    `json:"account_balance"`
	Currency      Currency                 `json:"currency"`
	DefaultSource *PaymentSource           `json:"default_source"`
	Delinquent    bool                     `json:"delinquent"`
	Desc          string                   `json:"description"`
	Discount      *Discount                `json:"discount"`
	Email         string                   `json:"email"`
	Meta          map[string]string        `json:"metadata"`
	Subs          *SubList                 `json:"subscriptions"`
	Deleted       bool                     `json:"deleted"`
	Shipping      *CustomerShippingDetails `json:"shipping"`
	BusinessVatID string                   `json:"business_vat_id"`
}

Customer is the resource representing a Stripe customer. For more details see https://stripe.com/docs/api#customers.

Example (Delete) 
package main

import (
	"log"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/customer"
)

func main() {
	stripe.Key = "sk_key"

	customerDel, err := customer.Del("cus_example_id")

	if err != nil {
		log.Fatal(err)
	}

	if !customerDel.Deleted {
		log.Fatal("Customer doesn't appear deleted while it should be")
	}
}

Output:

func (*Customer) UnmarshalJSON 

func (c *Customer) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Customer. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type CustomerList 

type CustomerList struct {
	ListMeta
	Values []*Customer `json:"data"`
}

CustomerList is a list of customers as retrieved from a list endpoint.

type CustomerListParams 

type CustomerListParams struct {
	ListParams
	Created int64
}

CustomerListParams is the set of parameters that can be used when listing customers. For more details see https://stripe.com/docs/api#list_customers.

type CustomerParams 

type CustomerParams struct {
	Params
	Balance        int64
	BalanceZero    bool
	Token, Coupon  string
	Source         *SourceParams
	Desc, Email    string
	Plan           string
	Quantity       uint64
	TrialEnd       int64
	DefaultSource  string
	Shipping       *CustomerShippingDetails
	BusinessVatID  string
	TaxPercent     float64
	TaxPercentZero bool
}

CustomerParams is the set of parameters that can be used when creating or updating a customer. For more details see https://stripe.com/docs/api#create_customer and https://stripe.com/docs/api#update_customer.

func (*CustomerParams) SetSource 

func (cp *CustomerParams) SetSource(sp interface{}) error

SetSource adds valid sources to a CustomerParams object, returning an error for unsupported sources.

type CustomerShippingDetails 

type CustomerShippingDetails struct {
	Name    string  `json:"name"`
	Address Address `json:"address"`
	Phone   string  `json:"phone"`
}

CustomerShippingDetails is the structure containing shipping information.

func (*CustomerShippingDetails) AppendDetails 

func (s *CustomerShippingDetails) AppendDetails(values *RequestValues)

AppendDetails adds the shipping details to the query string.

type CustomerSourceParams 

type CustomerSourceParams struct {
	Params
	Customer string
	Source   *SourceParams
}

CustomerSourceParams are used to manipulate a given Stripe Customer object's payment sources. For more details see https://stripe.com/docs/api#sources

func (*CustomerSourceParams) SetSource 

func (cp *CustomerSourceParams) SetSource(sp interface{}) error

SetSource adds valid sources to a CustomerSourceParams object, returning an error for unsupported sources.

type DOB 

type DOB struct {
	Day   int `json:"day"`
	Month int `json:"month"`
	Year  int `json:"year"`
}

DOB is a structure for an account owner's date of birth.

type DeliveryEstimate 

type DeliveryEstimate struct {
	Type EstimateType `json:"type"`
	// If Type == Range
	Earliest string `json:"earliest"`
	Latest   string `json:"latest"`
	// If Type == Exact
	Date string `json:"date"`
}

type Discount 

type Discount struct {
	Coupon   *Coupon `json:"coupon"`
	Customer string  `json:"customer"`
	Start    int64   `json:"start"`
	End      int64   `json:"end"`
	Sub      string  `json:"subscription"`
	Deleted  bool    `json:"deleted"`
}

Discount is the resource representing a Stripe discount. For more details see https://stripe.com/docs/api#discounts.

type Displayer 

type Displayer interface {
	Display() string
}

Displayer provides a human readable representation of a struct

type Dispute 

type Dispute struct {
	ID              string            `json:"id"`
	Live            bool              `json:"livemode"`
	Amount          uint64            `json:"amount"`
	Currency        Currency          `json:"currency"`
	Charge          string            `json:"charge"`
	Created         int64             `json:"created"`
	Refundable      bool              `json:"is_charge_refundable"`
	Reason          DisputeReason     `json:"reason"`
	Status          DisputeStatus     `json:"status"`
	Transactions    []*Transaction    `json:"balance_transactions"`
	Evidence        *DisputeEvidence  `json:"evidence"`
	EvidenceDetails *EvidenceDetails  `json:"evidence_details"`
	Meta            map[string]string `json:"metadata"`
}

Dispute is the resource representing a Stripe dispute. For more details see https://stripe.com/docs/api#disputes.

type DisputeEvidence 

type DisputeEvidence struct {
	ProductDesc                  string `json:"product_description"`
	CustomerName                 string `json:"customer_name"`
	CustomerEmail                string `json:"customer_email_address"`
	CustomerIP                   string `json:"customer_purchase_ip"`
	CustomerSig                  *File  `json:"customer_signature"`
	BillingAddress               string `json:"billing_address"`
	Receipt                      *File  `json:"receipt"`
	ShippingAddress              string `json:"shipping_address"`
	ShippingDate                 string `json:"shipping_date"`
	ShippingTracking             string `json:"shipping_tracking_number"`
	ShippingDoc                  *File  `json:"shipping_documentation"`
	RefundPolicy                 *File  `json:"refund_policy"`
	RefundPolicyDisclosure       string `json:"refund_policy_disclosure"`
	RefundRefusalReason          string `json:"refund_refusal_explanation"`
	CancellationPolicy           *File  `json:"cancellation_policy"`
	CancellationPolicyDisclosure string `json:"cancellation_policy_disclosure"`
	CancellationRebuttal         string `json:"cancellation_rebuttal"`
	ActivityLog                  string `json:"access_activity_log"`
	ServiceDate                  string `json:"service_date"`
	ServiceDoc                   *File  `json:"service_documentation"`
	DuplicateCharge              string `json:"duplicate_charge_id"`
	DuplicateChargeReason        string `json:"duplicate_charge_explanation"`
	DuplicateChargeDoc           *File  `json:"duplicate_charge_documentation"`
	CustomerComm                 *File  `json:"customer_communication"`
	UncategorizedText            string `json:"uncategorized_text"`
	UncategorizedFile            *File  `json:"uncategorized_file"`
}

DisputeEvidence is the structure that contains various details about the evidence submitted for the dispute. Almost all fields are strings since there structures (i.e. address) do not typically get parsed by anyone and are thus presented as-received.

type DisputeEvidenceParams 

type DisputeEvidenceParams struct {
	ProductDesc, CustomerName, CustomerEmail, CustomerIP, CustomerSig, BillingAddress, Receipt string
	ShippingAddress, ShippingDate, ShippingTracking, ShippingDoc                               string
	RefundPolicy, RefundPolicyDisclosure, RefundRefusalReason                                  string
	CancellationPolicy, CancellationPolicyDisclsoure, CancellationRebuttal                     string
	ActivityLog                                                                                string
	ServiceDate, ServiceDoc                                                                    string
	DuplicateCharge, DuplicateChargeReason, DuplicateChargeDoc                                 string
	CustomerComm, UncategorizedText, UncategorizedFile                                         string
}

DisputeEvidenceParams is the set of parameters that can be used when submitting evidence for disputes.

func (*DisputeEvidenceParams) AppendDetails 

func (e *DisputeEvidenceParams) AppendDetails(values *RequestValues)

AppendDetails adds the dispute evidence details to the query string values.

type DisputeList 

type DisputeList struct {
	ListMeta
	Values []*Dispute `json:"data"`
}

DisputeList is a list of disputes as retrieved from a list endpoint.

type DisputeListParams 

type DisputeListParams struct {
	ListParams
	Created int64
}

DisputeListParams is the set of parameters that can be used when listing disputes. For more details see https://stripe.com/docs/api#list_disputes.

type DisputeParams 

type DisputeParams struct {
	Params
	Evidence *DisputeEvidenceParams
}

DisputeParams is the set of parameters that can be used when updating a dispute. For more details see https://stripe.com/docs/api#update_dispute.

type DisputeReason 

type DisputeReason string

DisputeReason is the list of allowed values for a discount's reason. Allowed values are "duplicate", "fraudulent", "subscription_canceled", "product_unacceptable", "product_not_received", "unrecognized", "credit_not_processed", "general".

type DisputeStatus 

type DisputeStatus string

DisputeStatus is the list of allowed values for a discount's status. Allowed values are "won", "lost", "needs_response", "under_review", "warning_needs_response", "warning_under_review", "charge_refunded", "warning_closed".

type Error 

type Error struct {
	Type           ErrorType `json:"type"`
	Msg            string    `json:"message"`
	Code           ErrorCode `json:"code,omitempty"`
	Param          string    `json:"param,omitempty"`
	RequestID      string    `json:"request_id,omitempty"`
	HTTPStatusCode int       `json:"status,omitempty"`
	ChargeID       string    `json:"charge,omitempty"`

	// Err contains an internal error with an additional level of granularity
	// that can be used in some cases to get more detailed information about
	// what went wrong. For example, Err may hold a ChargeError that indicates
	// exactly what went wrong during a charge.
	Err error `json:"-"`
}

Error is the response returned when a call is unsuccessful. For more details see https://stripe.com/docs/api#errors.

func (*Error) Error 

func (e *Error) Error() string

Error serializes the error object to JSON and returns it as a string.

type ErrorCode 

type ErrorCode string

ErrorCode is the list of allowed values for the error's code.

type ErrorType 

type ErrorType string

ErrorType is the list of allowed values for the error's type.

type EstimateType 

type EstimateType string
const (
	Exact EstimateType = "exact"
	Range EstimateType = "range"
)

type Event 

type Event struct {
	ID       string     `json:"id"`
	Live     bool       `json:"livemode"`
	Created  int64      `json:"created"`
	Data     *EventData `json:"data"`
	Webhooks uint64     `json:"pending_webhooks"`
	Type     string     `json:"type"`
	Req      string     `json:"request"`
	UserID   string     `json:"user_id"`
}

Event is the resource representing a Stripe event. For more details see https://stripe.com/docs/api#events.

func (*Event) GetObjValue 

func (e *Event) GetObjValue(keys ...string) string

GetObjValue returns the value from the e.Data.Obj bag based on the keys hierarchy.

func (*Event) GetPrevValue 

func (e *Event) GetPrevValue(keys ...string) string

GetPrevValue returns the value from the e.Data.Prev bag based on the keys hierarchy.

type EventData 

type EventData struct {
	Raw  json.RawMessage        `json:"object"`
	Prev map[string]interface{} `json:"previous_attributes"`
	Obj  map[string]interface{}
}

EventData is the unmarshalled object as a map.

func (*EventData) UnmarshalJSON 

func (e *EventData) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of the EventData. This custom unmarshaling exists so that we can keep both the map and raw data.

type EventList 

type EventList struct {
	ListMeta
	Values []*Event `json:"data"`
}

EventList is a list of events as retrieved from a list endpoint.

type EventListParams 

type EventListParams struct {
	ListParams
	Created int64
	// Type is one of the values documented at https://stripe.com/docs/api#event_types.
	Type string
}

EventListParams is the set of parameters that can be used when listing events. For more details see https://stripe.com/docs/api#list_events.

type EvidenceDetails 

type EvidenceDetails struct {
	DueDate int64 `json:"due_by"`
	Count   int   `json:"submission_count"`
}

EvidenceDetails is the structure representing more details about the dispute.

type ExternalAccount 

type ExternalAccount struct {
	Type AccountType `json:"object"`
	ID   string      `json:"id"`

	// A bank account attached to an account. Populated only if the external
	// account is a bank account.
	BankAccount *BankAccount

	// A card attached to an account. Populated only if the external account is
	// a card.
	Card *Card
}

ExternalAccount is an external account (a bank account or card) that's attached to an account. It contains fields that will be conditionally populated depending on its type.

func (*ExternalAccount) UnmarshalJSON 

func (ea *ExternalAccount) UnmarshalJSON(b []byte) error

UnmarshalJSON implements Unmarshaler.UnmarshalJSON.

type ExternalAccountList 

type ExternalAccountList struct {
	ListMeta

	// Values contains any external accounts (bank accounts and/or cards)
	// currently attached to this account.
	Values []*ExternalAccount `json:"data"`
}

ExternalAccountList is a list of external accounts that may be either bank accounts or cards.

type Fee 

type Fee struct {
	ID             string         `json:"id"`
	Live           bool           `json:"livemode"`
	Account        *Account       `json:"account"`
	Amount         uint64         `json:"amount"`
	App            string         `json:"application"`
	Tx             *Transaction   `json:"balance_transaction"`
	Charge         *Charge        `json:"charge"`
	Created        int64          `json:"created"`
	Currency       Currency       `json:"currency"`
	Refunded       bool           `json:"refunded"`
	Refunds        *FeeRefundList `json:"refunds"`
	AmountRefunded uint64         `json:"amount_refunded"`
}

Fee is the resource representing a Stripe application fee. For more details see https://stripe.com/docs/api#application_fees.

func (*Fee) UnmarshalJSON 

func (f *Fee) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Fee. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type FeeList 

type FeeList struct {
	ListMeta
	Values []*Fee `json:"data"`
}

FeeList is a list of fees as retrieved from a list endpoint.

type FeeListParams 

type FeeListParams struct {
	ListParams
	Created int64
	Charge  string
}

FeeListParams is the set of parameters that can be used when listing application fees. For more details see https://stripe.com/docs/api#list_application_fees.

type FeeParams 

type FeeParams struct {
	Params
	Amount uint64
}

FeeParams is the set of parameters that can be used when refunding an application fee. For more details see https://stripe.com/docs/api#refund_application_fee.

type FeeRefund 

type FeeRefund struct {
	ID       string            `json:"id"`
	Amount   uint64            `json:"amount"`
	Created  int64             `json:"created"`
	Currency Currency          `json:"currency"`
	Tx       *Transaction      `json:"balance_transaction"`
	Fee      string            `json:"fee"`
	Meta     map[string]string `json:"metadata"`
}

FeeRefund is the resource representing a Stripe fee refund. For more details see https://stripe.com/docs/api#fee_refunds.

func (*FeeRefund) UnmarshalJSON 

func (f *FeeRefund) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a FeeRefund. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type FeeRefundList 

type FeeRefundList struct {
	ListMeta
	Values []*FeeRefund `json:"data"`
}

FeeRefundList is a list object for fee refunds.

type FeeRefundListParams 

type FeeRefundListParams struct {
	ListParams
	Fee string
}

FeeRefundListParams is the set of parameters that can be used when listing fee refunds. For more details see https://stripe.com/docs/api#list_fee_refunds.

type FeeRefundParams 

type FeeRefundParams struct {
	Params
	Fee    string
	Amount uint64
	Meta   map[string]string
}

FeeRefundParams is the set of parameters that can be used when refunding a fee. For more details see https://stripe.com/docs/api#fee_refund.

type File 

type File struct {
	ID      string `json:"id"`
	Created int64  `json:"created"`
	Size    int    `json:"size"`
	Purpose string `json:"purpose"`
	URL     string `json:"url"`
	Mime    string `json:"mime_type"`
}

File represents a link to downloadable content.

func (*File) UnmarshalJSON 

func (f *File) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a File. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type FileUpload 

type FileUpload struct {
	ID      string            `json:"id"`
	Created int64             `json:"created"`
	Size    int64             `json:"size"`
	Purpose FileUploadPurpose `json:"purpose"`
	URL     string            `json:"url"`
	Type    string            `json:"type"`
}

FileUpload is the resource representing a Stripe file upload. For more details see https://stripe.com/docs/api#file_uploads.

func (*FileUpload) UnmarshalJSON 

func (f *FileUpload) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a FileUpload. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type FileUploadList 

type FileUploadList struct {
	ListMeta
	Values []*FileUpload `json:"data"`
}

FileUploadList is a list of file uploads as retrieved from a list endpoint.

type FileUploadListParams 

type FileUploadListParams struct {
	Purpose FileUploadPurpose
	ListParams
}

FileUploadListParams is the set of parameters that can be used when listing file uploads. For more details see https://stripe.com/docs/api#list_file_uploads.

type FileUploadParams 

type FileUploadParams struct {
	Params
	Purpose FileUploadPurpose
	File    *os.File
}

FileUploadParams is the set of parameters that can be used when creating a file upload. For more details see https://stripe.com/docs/api#create_file_upload.

func (*FileUploadParams) AppendDetails 

func (f *FileUploadParams) AppendDetails(body io.ReadWriter) (string, error)

AppendDetails adds the file upload details to an io.ReadWriter. It returns the boundary string for a multipart/form-data request and an error (if one exists).

type FileUploadPurpose 

type FileUploadPurpose string

FileUploadPurpose is the purpose of a particular file upload. Allowed values are "dispute_evidence" and "identity_document".

type Filters 

type Filters struct {
	// contains filtered or unexported fields
}

Filters is a structure that contains a collection of filters for list-related APIs.

func (*Filters) AddFilter 

func (f *Filters) AddFilter(key, op, value string)

AddFilter adds a new filter with a given key, op and value.

func (*Filters) AppendTo 

func (f *Filters) AppendTo(values *RequestValues)

AppendTo adds the list of filters to the query string values.

type FraudDetails 

type FraudDetails struct {
	UserReport   FraudReport `json:"user_report"`
	StripeReport FraudReport `json:"stripe_report"`
}

FraudDetails is the structure detailing fraud status.

type FraudReport 

type FraudReport string

FraudReport is the list of allowed values for reporting fraud. Allowed values are "fraudulent", "safe".

type IdentityDocument 

type IdentityDocument struct {
	ID      string `json:"id"`
	Created int64  `json:"created"`
	Size    int64  `json:"size"`
}

IdentityDocument is the structure for an identity document.

func (*IdentityDocument) UnmarshalJSON 

func (d *IdentityDocument) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an IdentityDocument. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type IdentityVerification 

type IdentityVerification struct {
	Status   IdentityVerificationStatus `json:"status"`
	Document *IdentityDocument          `json:"document"`
	Details  *string                    `json:"details"`
}

IdentityVerification is the structure for an account's verification.

type IdentityVerificationStatus 

type IdentityVerificationStatus string

IdentityVerificationStatus describes the different statuses for identity verification. Current values are "pending", "verified", "unverified".

type Interval 

type Interval string

Interval describes the payout interval. Current values are "manual", "daily", "weekly", "monthly".

type InvalidRequestError 

type InvalidRequestError struct {
	// contains filtered or unexported fields
}

InvalidRequestError is an error that occurs when a request contains invalid parameters.

func (*InvalidRequestError) Error 

func (e *InvalidRequestError) Error() string

Error serializes the error object to JSON and returns it as a string.

type Inventory 

type Inventory struct {
	Type     string `json:"type"`
	Quantity int64  `json:"quantity"`
	Value    string `json:"value"`
}

type Invoice 

type Invoice struct {
	ID           string            `json:"id"`
	Live         bool              `json:"livemode"`
	Amount       int64             `json:"amount_due"`
	Attempts     uint64            `json:"attempt_count"`
	Attempted    bool              `json:"attempted"`
	Closed       bool              `json:"closed"`
	Currency     Currency          `json:"currency"`
	Customer     *Customer         `json:"customer"`
	Date         int64             `json:"date"`
	Forgive      bool              `json:"forgiven"`
	Lines        *InvoiceLineList  `json:"lines"`
	Paid         bool              `json:"paid"`
	End          int64             `json:"period_end"`
	Start        int64             `json:"period_start"`
	StartBalance int64             `json:"starting_balance"`
	Subtotal     int64             `json:"subtotal"`
	Total        int64             `json:"total"`
	Tax          int64             `json:"tax"`
	TaxPercent   float64           `json:"tax_percent"`
	Fee          uint64            `json:"application_fee"`
	Charge       *Charge           `json:"charge"`
	Desc         string            `json:"description"`
	Discount     *Discount         `json:"discount"`
	EndBalance   int64             `json:"ending_balance"`
	NextAttempt  int64             `json:"next_payment_attempt"`
	Statement    string            `json:"statement_descriptor"`
	Sub          string            `json:"subscription"`
	Webhook      int64             `json:"webhooks_delivered_at"`
	Meta         map[string]string `json:"metadata"`
}

Invoice is the resource representing a Stripe invoice. For more details see https://stripe.com/docs/api#invoice_object.

Example (Update) 
package main

import (
	"log"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/invoice"
)

func main() {
	stripe.Key = "sk_key"

	params := &stripe.InvoiceParams{
		Desc: "updated description",
	}

	inv, err := invoice.Update("sub_example_id", params)

	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", inv.Desc)
}

Output:

func (*Invoice) UnmarshalJSON 

func (i *Invoice) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an Invoice. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type InvoiceItem 

type InvoiceItem struct {
	ID           string            `json:"id"`
	Live         bool              `json:"livemode"`
	Amount       int64             `json:"amount"`
	Currency     Currency          `json:"currency"`
	Customer     *Customer         `json:"customer"`
	Date         int64             `json:"date"`
	Proration    bool              `json:"proration"`
	Desc         string            `json:"description"`
	Invoice      *Invoice          `json:"invoice"`
	Meta         map[string]string `json:"metadata"`
	Sub          string            `json:"subscription"`
	Discountable bool              `json:"discountable"`
	Deleted      bool              `json:"deleted"`
}

InvoiceItem is the resource represneting a Stripe invoice item. For more details see https://stripe.com/docs/api#invoiceitems.

func (*InvoiceItem) UnmarshalJSON 

func (i *InvoiceItem) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an InvoiceItem. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type InvoiceItemList 

type InvoiceItemList struct {
	ListMeta
	Values []*InvoiceItem `json:"data"`
}

InvoiceItemList is a list of invoice items as retrieved from a list endpoint.

type InvoiceItemListParams 

type InvoiceItemListParams struct {
	ListParams
	Created  int64
	Customer string
}

InvoiceItemListParams is the set of parameters that can be used when listing invoice items. For more details see https://stripe.com/docs/api#list_invoiceitems.

type InvoiceItemParams 

type InvoiceItemParams struct {
	Params
	Customer           string
	Amount             int64
	Currency           Currency
	Invoice, Desc, Sub string
	Discountable       bool
}

InvoiceItemParams is the set of parameters that can be used when creating or updating an invoice item. For more details see https://stripe.com/docs/api#create_invoiceitem and https://stripe.com/docs/api#update_invoiceitem.

type InvoiceLine 

type InvoiceLine struct {
	ID           string            `json:"id"`
	Live         bool              `json:"live_mode"`
	Amount       int64             `json:"amount"`
	Currency     Currency          `json:"currency"`
	Period       *Period           `json:"period"`
	Proration    bool              `json:"proration"`
	Type         InvoiceLineType   `json:"type"`
	Desc         string            `json:"description"`
	Meta         map[string]string `json:"metadata"`
	Plan         *Plan             `json:"plan"`
	Quantity     int64             `json:"quantity"`
	Sub          string            `json:"subscription"`
	Discountable bool              `json:"discountable"`
}

InvoiceLine is the resource representing a Stripe invoice line item. For more details see https://stripe.com/docs/api#invoice_line_item_object.

type InvoiceLineList 

type InvoiceLineList struct {
	ListMeta
	Values []*InvoiceLine `json:"data"`
}

InvoiceLineList is a list object for invoice line items.

type InvoiceLineListParams 

type InvoiceLineListParams struct {
	ListParams
	ID            string
	Customer, Sub string
}

InvoiceLineListParams is the set of parameters that can be used when listing invoice line items. For more details see https://stripe.com/docs/api#invoice_lines.

type InvoiceLineType 

type InvoiceLineType string

InvoiceLineType is the list of allowed values for the invoice line's type. Allowed values are "invoiceitem", "subscription".

type InvoiceList 

type InvoiceList struct {
	ListMeta
	Values []*Invoice `json:"data"`
}

InvoiceList is a list of invoices as retrieved from a list endpoint.

type InvoiceListParams 

type InvoiceListParams struct {
	ListParams
	Date     int64
	Customer string
}

InvoiceListParams is the set of parameters that can be used when listing invoices. For more details see https://stripe.com/docs/api#list_customer_invoices.

type InvoiceParams 

type InvoiceParams struct {
	Params
	Customer             string
	Desc, Statement, Sub string
	Fee                  uint64
	Closed, Forgive      bool
	SubPlan              string
	SubNoProrate         bool
	SubProrationDate     int64
	SubProrationDateNow  bool
	SubQuantity          uint64
	SubTrialEnd          int64
	TaxPercent           float64
	TaxPercentZero       bool
}

InvoiceParams is the set of parameters that can be used when creating or updating an invoice. For more details see https://stripe.com/docs/api#create_invoice, https://stripe.com/docs/api#update_invoice.

type Iter 

type Iter struct {
	// contains filtered or unexported fields
}

Iter provides a convenient interface for iterating over the elements returned from paginated list API calls. Successive calls to the Next method will step through each item in the list, fetching pages of items as needed. Iterators are not thread-safe, so they should not be consumed across multiple goroutines.

func GetIter 

func GetIter(params *ListParams, qs *RequestValues, query Query) *Iter

GetIter returns a new Iter for a given query and its options.

func (*Iter) Current 

func (it *Iter) Current() interface{}

Current returns the most recent item visited by a call to Next.

func (*Iter) Err 

func (it *Iter) Err() error

Err returns the error, if any, that caused the Iter to stop. It must be inspected after Next returns false.

func (*Iter) Meta 

func (it *Iter) Meta() *ListMeta

Meta returns the list metadata.

func (*Iter) Next 

func (it *Iter) Next() bool

Next advances the Iter to the next item in the list, which will then be available through the Current method. It returns false when the iterator stops at the end of the list.

type LegalEntity 

type LegalEntity struct {
	Type                  LegalEntityType      `json:"type"`
	BusinessName          string               `json:"business_name"`
	Address               Address              `json:"address"`
	First                 string               `json:"first_name"`
	Last                  string               `json:"last_name"`
	PersonalAddress       Address              `json:"personal_address"`
	DOB                   DOB                  `json:"dob"`
	AdditionalOwners      []Owner              `json:"additional_owners"`
	Verification          IdentityVerification `json:"verification"`
	SSN                   string               `json:"ssn_last_4"`
	SSNProvided           bool                 `json:"ssn_last_4_provided"`
	PersonalID            string               `json:"personal_id_number"`
	PersonalIDProvided    bool                 `json:"personal_id_number_provided"`
	BusinessTaxID         string               `json:"business_tax_id"`
	BusinessTaxIDProvided bool                 `json:"business_tax_id_provided"`
	BusinessVatID         string               `json:"business_vat_id"`
}

LegalEntity is the structure for properties related to an account's legal state.

func (*LegalEntity) AppendDetails 

func (l *LegalEntity) AppendDetails(values *RequestValues)

AppendDetails adds the legal entity to the query string.

type LegalEntityType 

type LegalEntityType string

LegalEntityType describes the types for a legal entity. Current values are "individual", "company".

type ListMeta 

type ListMeta struct {
	Count uint32 `json:"total_count"`
	More  bool   `json:"has_more"`
	URL   string `json:"url"`
}

ListMeta is the structure that contains the common properties of List iterators. The Count property is only populated if the total_count include option is passed in (see tests for example).

type ListParams 

type ListParams struct {
	Exp        []string
	Start, End string
	Limit      int
	Filters    Filters
	// By default, listing through an iterator will automatically grab
	// additional pages as the query progresses. To change this behavior
	// and just load a single page, set this to true.
	Single bool

	// StripeAccount may contain the ID of a connected account. By including
	// this field, the request is made as if it originated from the connected
	// account instead of under the account of the owner of the configured
	// Stripe key.
	StripeAccount string
}

ListParams is the structure that contains the common properties of any *ListParams structure.

func (*ListParams) AppendTo 

func (p *ListParams) AppendTo(body *RequestValues)

AppendTo adds the common parameters to the query string values.

func (*ListParams) Expand 

func (p *ListParams) Expand(f string)

Expand appends a new field to expand.

func (*ListParams) ToParams 

func (p *ListParams) ToParams() *Params

ToParams converts a ListParams to a Params by moving over any fields that have valid targets in the new type. This is useful because fields in Params can be injected directly into an http.Request while generally ListParams is only used to build a set of parameters.

type Order 

type Order struct {
	ID                     string            `json:"id"`
	Amount                 int64             `json:"amount"`
	Application            string            `json:"application"`
	ApplicationFee         int64             `json:"application_fee"`
	Charge                 Charge            `json:"charge"`
	Created                int64             `json:"created"`
	Currency               Currency          `json:"currency"`
	Customer               Customer          `json:"customer"`
	Email                  string            `json:"email"`
	Items                  []OrderItem       `json:"items"`
	Meta                   map[string]string `json:"metadata"`
	Returns                *OrderReturnList  `json:"returns"`
	SelectedShippingMethod *string           `json:"selected_shipping_method"`
	Shipping               Shipping          `json:"shipping"`
	ShippingMethods        []ShippingMethod  `json:"shipping_methods"`
	Status                 OrderStatus       `json:"status"`
	Updated                int64             `json:"updated"`
}

func (*Order) UnmarshalJSON 

func (o *Order) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an Order. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type OrderItem 

type OrderItem struct {
	Amount      int64              `json:"amount"`
	Currency    Currency           `json:"currency"`
	Description string             `json:"description"`
	Parent      string             `json:"parent"`
	Quantity    int64              `json:"quantity"`
	Type        orderitem.ItemType `json:"type"`
}

type OrderItemParams 

type OrderItemParams struct {
	Amount      int64
	Currency    Currency
	Description string
	Parent      string
	Quantity    *int64
	Type        orderitem.ItemType
}

type OrderList 

type OrderList struct {
	ListMeta
	Values []*Order `json:"data"`
}

OrderList is a list of orders as retrieved from a list endpoint.

type OrderListParams 

type OrderListParams struct {
	ListParams
	IDs    []string
	Status OrderStatus
}

OrderListParams is the set of parameters that can be used when listing orders. For more details, see: https://stripe.com/docs/api#list_orders.

type OrderParams 

type OrderParams struct {
	Params
	Currency Currency
	Customer string
	Email    string
	Items    []*OrderItemParams
	Shipping *ShippingParams
}

type OrderPayParams 

type OrderPayParams struct {
	Params
	Source         *SourceParams
	Customer       string
	ApplicationFee int64
	Email          string
}

OrderPayParams is the set of parameters that can be used when paying orders. For more details, see: https://stripe.com/docs/api#pay_order.

func (*OrderPayParams) SetSource 

func (op *OrderPayParams) SetSource(sp interface{}) error

SetSource adds valid sources to a OrderParams object, returning an error for unsupported sources.

type OrderReturn 

type OrderReturn struct {
	ID       string      `json:"id"`
	Amount   int64       `json:"amount"`
	Created  int64       `json:"created"`
	Currency Currency    `json:"currency"`
	Items    []OrderItem `json:"items"`
	Live     bool        `json:"livemode"`
	Order    Order       `json:"order"`
	Refund   *Refund     `json:"refund"`
}

func (*OrderReturn) UnmarshalJSON 

func (ret *OrderReturn) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an OrderReturn. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type OrderReturnList 

type OrderReturnList struct {
	ListMeta
	Values []*OrderReturn `json:"data"`
}

OrderReturnList is a list of returns as retrieved from a list endpoint.

type OrderReturnListParams 

type OrderReturnListParams struct {
	ListParams
	Order string
}

OrderReturnListParams is the set of parameters that can be used when listing returns. For more details, see: https://stripe.com/docs/api#list_order_returns.

type OrderReturnParams 

type OrderReturnParams struct {
	Params
	Items []*OrderItemParams
}

OrderReturnParams is the set of parameters that can be used when returning orders. For more details, see: https://stripe.com/docs/api#return_order.

type OrderStatus 

type OrderStatus string

OrderStatus represents the statuses of an order object. 

const (
	StatusCreated   OrderStatus = "created"
	StatusPaid      OrderStatus = "paid"
	StatusCanceled  OrderStatus = "canceled"
	StatusFulfilled OrderStatus = "fulfilled"
	StatusReturned  OrderStatus = "returned"
)

type OrderUpdateParams 

type OrderUpdateParams struct {
	Params
	Coupon                 string
	SelectedShippingMethod string
	Status                 OrderStatus
}

type Owner 

type Owner struct {
	First        string               `json:"first_name"`
	Last         string               `json:"last_name"`
	DOB          DOB                  `json:"dob"`
	Address      Address              `json:"address"`
	Verification IdentityVerification `json:"verification"`
}

Owner is the structure for an account owner.

type PIIParams 

type PIIParams struct {
	Params
	PersonalIDNumber string
}

PIIParams are parameters for personal identifiable information (PII).

func (*PIIParams) AppendDetails 

func (p *PIIParams) AppendDetails(values *RequestValues)

AppendDetails adds the PII data's details to the query string values.

type PackageDimensions 

type PackageDimensions struct {
	Height float64 `json:"height"`
	Length float64 `json:"length"`
	Width  float64 `json:"width"`
	Weight float64 `json:"weight"`
}

PackageDimensions represents the dimension of a product or a sku from the perspective of shipping.

type Params 

type Params struct {
	Exp            []string
	Meta           map[string]string
	Extra          url.Values
	IdempotencyKey string

	// StripeAccount may contain the ID of a connected account. By including
	// this field, the request is made as if it originated from the connected
	// account instead of under the account of the owner of the configured
	// Stripe key.
	StripeAccount string

	// Account is deprecated form of StripeAccount that will do the same thing.
	// Please use StripeAccount instead.
	Account string
}

Params is the structure that contains the common properties of any *Params structure.

func (*Params) AddExtra 

func (p *Params) AddExtra(key, value string)

AddExtra adds a new arbitrary key-value pair to the request data

func (*Params) AddMeta added in v1.0.3 

func (p *Params) AddMeta(key, value string)

AddMeta adds a new key-value pair to the Metadata.

func (*Params) AppendTo 

func (p *Params) AppendTo(body *RequestValues)

AppendTo adds the common parameters to the query string values.

func (*Params) Expand 

func (p *Params) Expand(f string)

Expand appends a new field to expand.

func (*Params) SetAccount 

func (p *Params) SetAccount(val string)

SetAccount sets a value for the Stripe-Account header.

func (*Params) SetStripeAccount 

func (p *Params) SetStripeAccount(val string)

SetStripeAccount sets a value for the Stripe-Account header.

type PaymentSource 

type PaymentSource struct {
	Type            PaymentSourceType `json:"object"`
	ID              string            `json:"id"`
	Card            *Card             `json:"-"`
	BitcoinReceiver *BitcoinReceiver  `json:"-"`
	BankAccount     *BankAccount      `json:"-"`
	Deleted         bool              `json:"deleted"`
}

PaymentSource describes the payment source used to make a Charge. The Type should indicate which object is fleshed out (eg. BitcoinReceiver or Card) For more details see https://stripe.com/docs/api#retrieve_charge

func (*PaymentSource) Display 

func (s *PaymentSource) Display() string

Display human readable representation of source.

func (*PaymentSource) MarshalJSON 

func (s *PaymentSource) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a PaymentSource. This custom marshaling is needed because the specific type of payment instrument it represents is specified by the PaymentSourceType

func (*PaymentSource) UnmarshalJSON 

func (s *PaymentSource) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a PaymentSource. This custom unmarshaling is needed because the specific type of payment instrument it refers to is specified in the JSON

type PaymentSourceType 

type PaymentSourceType string

PaymentSourceType consts represent valid payment sources. 

const (
	// PaymentSourceBankAccount is a constant representing a payment source
	// which is a bank account.
	PaymentSourceBankAccount PaymentSourceType = "bank_account"

	// PaymentSourceBitcoinReceiver is a constant representing a payment source
	// which is a Bitcoin receiver.
	PaymentSourceBitcoinReceiver PaymentSourceType = "bitcoin_receiver"

	// PaymentSourceCard is a constant representing a payment source which is a
	// card.
	PaymentSourceCard PaymentSourceType = "card"
)

type Period 

type Period struct {
	Start int64 `json:"start"`
	End   int64 `json:"end"`
}

Period is a structure representing a start and end dates.

type Plan 

type Plan struct {
	ID            string            `json:"id"`
	Live          bool              `json:"livemode"`
	Amount        uint64            `json:"amount"`
	Created       int64             `json:"created"`
	Currency      Currency          `json:"currency"`
	Interval      PlanInterval      `json:"interval"`
	IntervalCount uint64            `json:"interval_count"`
	Name          string            `json:"name"`
	Meta          map[string]string `json:"metadata"`
	TrialPeriod   uint64            `json:"trial_period_days"`
	Statement     string            `json:"statement_descriptor"`
	Deleted       bool              `json:"deleted"`
}

Plan is the resource representing a Stripe plan. For more details see https://stripe.com/docs/api#plans.

Example (List) 
package main

import (
	"log"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/plan"
)

func main() {
	stripe.Key = "sk_key"

	params := &stripe.PlanListParams{}
	params.Filters.AddFilter("limit", "", "3")
	params.Single = true

	it := plan.List(params)
	for it.Next() {
		log.Printf("%v ", it.Plan().Name)
	}
	if err := it.Err(); err != nil {
		log.Fatal(err)
	}
}

Output:

type PlanInterval added in v1.0.1 

type PlanInterval string

PlanInterval is the list of allowed values for a plan's interval. Allowed values are "day", "week", "month", "year".

type PlanList 

type PlanList struct {
	ListMeta
	Values []*Plan `json:"data"`
}

PlanList is a list of plans as returned from a list endpoint.

type PlanListParams 

type PlanListParams struct {
	ListParams
}

PlanListParams is the set of parameters that can be used when listing plans. For more details see https://stripe.com/docs/api#list_plans.

type PlanParams 

type PlanParams struct {
	Params
	ID, Name                   string
	Currency                   Currency
	Amount                     uint64
	Interval                   PlanInterval
	IntervalCount, TrialPeriod uint64
	Statement                  string
}

PlanParams is the set of parameters that can be used when creating or updating a plan. For more details see https://stripe.com/docs/api#create_plan and https://stripe.com/docs/api#update_plan.

type Product 

type Product struct {
	ID                string             `json:"id"`
	Created           int64              `json:"created"`
	Updated           int64              `json:"updated"`
	Live              bool               `json:"livemode"`
	Active            bool               `json:"active"`
	Name              string             `json:"name"`
	Caption           string             `json:"caption"`
	Desc              string             `json:"description"`
	Attrs             []string           `json:"attributes"`
	Shippable         bool               `json:"shippable"`
	PackageDimensions *PackageDimensions `json:"package_dimensions"`
	Images            []string           `json:"images"`
	Meta              map[string]string  `json:"metadata"`
	URL               string             `json:"url"`
	Skus              *SKUList           `json:"skus"`
}

Product is the resource representing a Stripe product. For more details see https://stripe.com/docs/api#products.

func (*Product) UnmarshalJSON 

func (p *Product) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Product. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type ProductList 

type ProductList struct {
	ListMeta
	Values []*Product `json:"data"`
}

ProductList is a list of products as retrieved from a list endpoint.

type ProductListParams 

type ProductListParams struct {
	ListParams
	Active    *bool
	IDs       []string
	Shippable *bool
	URL       string
}

ProductListParams is the set of parameters that can be used when listing products. For more details, see: https://stripe.com/docs/api#list_products.

type ProductParams 

type ProductParams struct {
	Params
	ID                string
	Active            *bool
	Name              string
	Caption           string
	Desc              string
	Attrs             []string
	Images            []string
	URL               string
	Shippable         *bool
	PackageDimensions *PackageDimensions
}

ProductParams is the set of parameters that can be used when creating or updating a product. For more details, see https://stripe.com/docs/api#create_product and https://stripe.com/docs/api#update_product.

type Query 

type Query func(*RequestValues) ([]interface{}, ListMeta, error)

Query is the function used to get a page listing.

type RateLimitError 

type RateLimitError struct {
	// contains filtered or unexported fields
}

RateLimitError occurs when the Stripe API is hit to with too many requests too quickly and indicates that the current request has been rate limited.

func (*RateLimitError) Error 

func (e *RateLimitError) Error() string

Error serializes the error object to JSON and returns it as a string.

type Recipient 

type Recipient struct {
	ID          string            `json:"id"`
	Live        bool              `json:"livemode"`
	Created     int64             `json:"created"`
	Type        RecipientType     `json:"type"`
	Bank        *BankAccount      `json:"active_account"`
	Desc        string            `json:"description"`
	Email       string            `json:"email"`
	Meta        map[string]string `json:"metadata"`
	Name        string            `json:"name"`
	Cards       *CardList         `json:"cards"`
	DefaultCard *Card             `json:"default_card"`
	Deleted     bool              `json:"deleted"`
}

Recipient is the resource representing a Stripe recipient. For more details see https://stripe.com/docs/api#recipients.

func (*Recipient) UnmarshalJSON 

func (r *Recipient) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Recipient. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type RecipientList 

type RecipientList struct {
	ListMeta
	Values []*Recipient `json:"data"`
}

RecipientList is a list of recipients as retrieved from a list endpoint.

type RecipientListParams 

type RecipientListParams struct {
	ListParams
	Verified bool
}

RecipientListParams is the set of parameters that can be used when listing recipients. For more details see https://stripe.com/docs/api#list_recipients.

type RecipientParams 

type RecipientParams struct {
	Params
	Name                      string
	Type                      RecipientType
	TaxID, Token, Email, Desc string
	Bank                      *BankAccountParams
	Card                      *CardParams
	DefaultCard               string
}

RecipientParams is the set of parameters that can be used when creating or updating recipients. For more details see https://stripe.com/docs/api#create_recipient and https://stripe.com/docs/api#update_recipient.

type RecipientType 

type RecipientType string

RecipientType is the list of allowed values for the recipient's type. Allowed values are "individual", "corporation".

type Refund 

type Refund struct {
	ID       string            `json:"id"`
	Amount   uint64            `json:"amount"`
	Created  int64             `json:"created"`
	Currency Currency          `json:"currency"`
	Tx       *Transaction      `json:"balance_transaction"`
	Charge   string            `json:"charge"`
	Meta     map[string]string `json:"metadata"`
	Reason   RefundReason      `json:"reason"`
}

Refund is the resource representing a Stripe refund. For more details see https://stripe.com/docs/api#refunds.

func (*Refund) UnmarshalJSON 

func (r *Refund) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Refund. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type RefundList 

type RefundList struct {
	ListMeta
	Values []*Refund `json:"data"`
}

RefundList is a list object for refunds.

type RefundListParams 

type RefundListParams struct {
	ListParams
}

RefundListParams is the set of parameters that can be used when listing refunds. For more details see https://stripe.com/docs/api#list_refunds.

type RefundParams 

type RefundParams struct {
	Params
	Charge        string
	Amount        uint64
	Fee, Transfer bool
	Reason        RefundReason
}

RefundParams is the set of parameters that can be used when refunding a charge. For more details see https://stripe.com/docs/api#refund.

type RefundReason 

type RefundReason string

RefundReason is, if set, the reason the refund is being made--allowed values are "fraudulent", "duplicate", and "requested_by_customer".

type RequestValues 

type RequestValues struct {
	// contains filtered or unexported fields
}

RequestValues is a collection of values that can be submitted along with a request that specifically allows for duplicate keys and encodes its entries in the same order that they were added.

func (*RequestValues) Add 

func (f *RequestValues) Add(key, val string)

Add adds a key/value tuple to the form.

func (*RequestValues) Empty 

func (f *RequestValues) Empty() bool

Empty returns true if no parameters have been set.

func (*RequestValues) Encode 

func (f *RequestValues) Encode() string

Encode encodes the values into “URL encoded” form ("bar=baz&foo=quux").

func (*RequestValues) Set 

func (f *RequestValues) Set(key, val string)

Set sets the first instance of a parameter for the given key to the given value. If no parameters exist with the key, a new one is added.

Note that Set is O(n) and may be quite slow for a very large parameter list.

func (*RequestValues) ToValues 

func (f *RequestValues) ToValues() url.Values

ToValues converts an instance of RequestValues into an instance of url.Values. This can be useful in cases where it's useful to make an unordered comparison of two sets of request values.

Note that url.Values is incapable of representing certain Rack form types in a cohesive way. For example, an array of maps in Rack is encoded with a string like: 

arr[][foo]=foo0&arr[][bar]=bar0&arr[][foo]=foo1&arr[][bar]=bar1

Because url.Values is a map, values will be handled in a way that's grouped by their key instead of in the order they were added. Therefore the above may by encoded to something like (maps are unordered so the actual result is somewhat non-deterministic): 

arr[][foo]=foo0&arr[][foo]=foo1&arr[][bar]=bar0&arr[][bar]=bar1

And thus result in an incorrect request to Stripe.

type Reversal 

type Reversal struct {
	ID       string            `json:"id"`
	Amount   uint64            `json:"amount"`
	Created  int64             `json:"created"`
	Currency Currency          `json:"currency"`
	Transfer string            `json:"transfer"`
	Meta     map[string]string `json:"metadata"`
	Tx       *Transaction      `json:"balance_transaction"`
}

Reversal represents a transfer reversal.

func (*Reversal) UnmarshalJSON 

func (r *Reversal) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Reversal. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type ReversalList 

type ReversalList struct {
	ListMeta
	Values []*Reversal `json:"data"`
}

ReversalList is a list of object for reversals.

type ReversalListParams 

type ReversalListParams struct {
	ListParams
	Transfer string
}

ReversalListParams is the set of parameters that can be used when listing reversals.

type ReversalParams 

type ReversalParams struct {
	Params
	Transfer string
	Amount   uint64
	Fee      bool
}

ReversalParams is the set of parameters that can be used when reversing a transfer.

type SKU 

type SKU struct {
	ID                string             `json:"id"`
	Created           int64              `json:"created"`
	Updated           int64              `json:"updated"`
	Live              bool               `json:"livemode"`
	Active            bool               `json:"active"`
	Desc              string             `json:"description"`
	Attrs             map[string]string  `json:"attributes"`
	Price             int64              `json:"price"`
	Currency          string             `json:"currency"`
	PackageDimensions *PackageDimensions `json:"package_dimensions"`
	Image             string             `json:"image"`
	Inventory         Inventory          `json:"inventory"`
	Product           Product            `json:"product"`
	Meta              map[string]string  `json:"metadata"`
}

func (*SKU) UnmarshalJSON 

func (s *SKU) UnmarshalJSON(data []byte) error

type SKUList 

type SKUList struct {
	ListMeta
	Values []*SKU `json:"data"`
}

type SKUListParams 

type SKUListParams struct {
	ListParams
	Active     *bool
	Product    string
	Attributes map[string]string
	IDs        []string
	InStock    *bool
}

type SKUParams 

type SKUParams struct {
	Params
	ID                string
	Active            *bool
	Desc              string
	Attrs             map[string]string
	Price             int64
	Currency          string
	Image             string
	Inventory         Inventory
	Product           string
	PackageDimensions *PackageDimensions
}

type Shipping 

type Shipping struct {
	Name    string  `json:"name"`
	Address Address `json:"address"`
	Phone   string  `json:"phone"`
}

type ShippingDetails 

type ShippingDetails struct {
	Name     string  `json:"name"`
	Address  Address `json:"address"`
	Phone    string  `json:"phone"`
	Tracking string  `json:"tracking_number"`
	Carrier  string  `json:"carrier"`
}

ShippingDetails is the structure containing shipping information.

func (*ShippingDetails) AppendDetails 

func (s *ShippingDetails) AppendDetails(values *RequestValues)

AppendDetails adds the shipping details to the query string.

type ShippingMethod 

type ShippingMethod struct {
	ID               string            `json:"id"`
	Amount           int64             `json:"amount"`
	Currency         Currency          `json:"currency"`
	Description      string            `json:"description"`
	DeliveryEstimate *DeliveryEstimate `json:"delivery_estimate"`
}

type ShippingParams 

type ShippingParams struct {
	Name    string
	Address *AddressParams
	Phone   string
}

type SourceList 

type SourceList struct {
	ListMeta
	Values []*PaymentSource `json:"data"`
}

SourceList is a list object for cards.

type SourceListParams 

type SourceListParams struct {
	ListParams
	Customer string
}

SourceListParams are used to enumerate the payment sources that are attached to a Customer.

type SourceParams 

type SourceParams struct {
	Token string
	Card  *CardParams
}

SourceParams is a union struct used to describe an arbitrary payment source.

func SourceParamsFor 

func SourceParamsFor(obj interface{}) (*SourceParams, error)

SourceParamsFor creates SourceParams objects around supported payment sources, returning errors if not.

Currently supported source types are Card (CardParams) and Tokens/IDs (string), where Tokens could be single use card tokens or bitcoin receiver ids

func (*SourceParams) AppendDetails 

func (sp *SourceParams) AppendDetails(values *RequestValues, creating bool)

AppendDetails adds the source's details to the query string values. For cards: when creating a new one, the parameters are passed as a dictionary, but on updates they are simply the parameter name.

type SourceVerifyParams 

type SourceVerifyParams struct {
	Params
	Customer string
	Amounts  [2]uint8
}

SourceVerifyParams are used to verify a customer source For more details see https://stripe.com/docs/guides/ach-beta

type Sub 

type Sub struct {
	ID          string            `json:"id"`
	EndCancel   bool              `json:"cancel_at_period_end"`
	Customer    *Customer         `json:"customer"`
	Plan        *Plan             `json:"plan"`
	Quantity    uint64            `json:"quantity"`
	Status      SubStatus         `json:"status"`
	FeePercent  float64           `json:"application_fee_percent"`
	Canceled    int64             `json:"canceled_at"`
	Created     int64             `json:"created"`
	Start       int64             `json:"start"`
	PeriodEnd   int64             `json:"current_period_end"`
	PeriodStart int64             `json:"current_period_start"`
	Discount    *Discount         `json:"discount"`
	Ended       int64             `json:"ended_at"`
	Meta        map[string]string `json:"metadata"`
	TaxPercent  float64           `json:"tax_percent"`
	TrialEnd    int64             `json:"trial_end"`
	TrialStart  int64             `json:"trial_start"`
}

Sub is the resource representing a Stripe subscription. For more details see https://stripe.com/docs/api#subscriptions.

func (*Sub) UnmarshalJSON 

func (s *Sub) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Sub. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type SubList 

type SubList struct {
	ListMeta
	Values []*Sub `json:"data"`
}

SubList is a list object for subscriptions.

type SubListParams 

type SubListParams struct {
	ListParams
	Customer string
	Plan     string
}

SubListParams is the set of parameters that can be used when listing active subscriptions. For more details see https://stripe.com/docs/api#list_subscriptions.

type SubParams 

type SubParams struct {
	Params
	Customer, Plan                                  string
	Coupon, Token                                   string
	TrialEnd                                        int64
	Card                                            *CardParams
	Quantity                                        uint64
	ProrationDate                                   int64
	FeePercent, TaxPercent                          float64
	TaxPercentZero                                  bool
	NoProrate, EndCancel, QuantityZero, TrialEndNow bool
	BillingCycleAnchor                              int64
	BillingCycleAnchorNow                           bool
}

SubParams is the set of parameters that can be used when creating or updating a subscription. For more details see https://stripe.com/docs/api#create_subscription and https://stripe.com/docs/api#update_subscription.

type SubStatus 

type SubStatus string

SubStatus is the list of allowed values for the subscription's status. Allowed values are "trialing", "active", "past_due", "canceled", "unpaid".

type SupportedBackend 

type SupportedBackend string

SupportedBackend is an enumeration of supported Stripe endpoints. Currently supported values are "api" and "uploads".

type TOSAcceptanceParams 

type TOSAcceptanceParams struct {
	Date      int64  `json:"date"`
	IP        string `json:"ip"`
	UserAgent string `json:"user_agent"`
}

TOSAcceptanceParams is the structure for TOS acceptance.

func (*TOSAcceptanceParams) AppendDetails 

func (t *TOSAcceptanceParams) AppendDetails(values *RequestValues)

AppendDetails adds the terms of service acceptance to the query string.

type Token 

type Token struct {
	ID       string       `json:"id"`
	Live     bool         `json:"livemode"`
	Created  int64        `json:"created"`
	Type     TokenType    `json:"type"`
	Used     bool         `json:"used"`
	Bank     *BankAccount `json:"bank_account"`
	Card     *Card        `json:"card"`
	ClientIP string       `json:"client_ip"`
	// Email is an undocumented field but included for all tokens created
	// with Stripe Checkout.
	Email string `json:"email"`
}

Token is the resource representing a Stripe token. For more details see https://stripe.com/docs/api#tokens.

type TokenParams 

type TokenParams struct {
	Params
	Card     *CardParams
	Bank     *BankAccountParams
	PII      *PIIParams
	Customer string
	// Email is an undocumented parameter used by Stripe Checkout
	// It may be removed from the API without notice.
	Email string
}

TokenParams is the set of parameters that can be used when creating a token. For more details see https://stripe.com/docs/api#create_card_token and https://stripe.com/docs/api#create_bank_account_token.

type TokenType 

type TokenType string

TokenType is the list of allowed values for a token's type. Allowed values are "card", "bank_account".

type TokenizationMethod 

type TokenizationMethod string

TokenizationMethod is the list of allowed values for the card's tokenization method. Allowed values are "apple_pay", "android_pay".

type Transaction 

type Transaction struct {
	ID         string            `json:"id"`
	Amount     int64             `json:"amount"`
	Currency   Currency          `json:"currency"`
	Available  int64             `json:"available_on"`
	Created    int64             `json:"created"`
	Fee        int64             `json:"fee"`
	FeeDetails []TxFee           `json:"fee_details"`
	Net        int64             `json:"net"`
	Status     TransactionStatus `json:"status"`
	Type       TransactionType   `json:"type"`
	Desc       string            `json:"description"`
	Src        string            `json:"source"`
	Recipient  string            `json:"recipient"`
}

Transaction is the resource representing the balance transaction. For more details see https://stripe.com/docs/api/#balance.

func (*Transaction) UnmarshalJSON 

func (t *Transaction) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Transaction. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type TransactionList 

type TransactionList struct {
	ListMeta
	Values []*Transaction `json:"data"`
}

TransactionList is a list of transactions as returned from a list endpoint.

type TransactionStatus 

type TransactionStatus string

TransactionStatus is the list of allowed values for the transaction's status. Allowed values are "available", "pending".

type TransactionType 

type TransactionType string

TransactionType is the list of allowed values for the transaction's type. Allowed values are "charge", "refund", "adjustment", "application_fee", "application_fee_refund", "transfer", "transfer_cancel", "transfer_failure".

type Transfer 

type Transfer struct {
	ID             string             `json:"id"`
	Live           bool               `json:"livemode"`
	Amount         int64              `json:"amount"`
	AmountReversed int64              `json:"amount_reversed"`
	Currency       Currency           `json:"currency"`
	Created        int64              `json:"created"`
	Date           int64              `json:"date"`
	Desc           string             `json:"description"`
	FailCode       TransferFailCode   `json:"failure_code"`
	FailMsg        string             `json:"failure_message"`
	Status         TransferStatus     `json:"status"`
	Type           TransferType       `json:"type"`
	Tx             *Transaction       `json:"balance_transaction"`
	Meta           map[string]string  `json:"metadata"`
	Bank           *BankAccount       `json:"bank_account"`
	Card           *Card              `json:"card"`
	Recipient      *Recipient         `json:"recipient"`
	Statement      string             `json:"statement_descriptor"`
	Reversals      *ReversalList      `json:"reversals"`
	Reversed       bool               `json:"reversed"`
	SourceTx       *Transaction       `json:"source_transaction"`
	SourceType     TransferSourceType `json:"source_type"`
}

Transfer is the resource representing a Stripe transfer. For more details see https://stripe.com/docs/api#transfers.

func (*Transfer) UnmarshalJSON 

func (t *Transfer) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of a Transfer. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

type TransferFailCode 

type TransferFailCode string

TransferFailCode is the list of allowed values for the transfer's failure code. Allowed values are "insufficient_funds", "account_closed", "no_account", "invalid_account_number", "debit_not_authorized", "bank_ownership_changed", "account_frozen", "could_not_process", "bank_account_restricted", "invalid_currency".

type TransferList 

type TransferList struct {
	ListMeta
	Values []*Transfer `json:"data"`
}

TransferList is a list of transfers as retrieved from a list endpoint.

type TransferListParams 

type TransferListParams struct {
	ListParams
	Created, Date int64
	Recipient     string
	Status        TransferStatus
}

TransferListParams is the set of parameters that can be used when listing transfers. For more details see https://stripe.com/docs/api#list_transfers.

type TransferParams 

type TransferParams struct {
	Params
	Amount                                                 int64
	Fee                                                    uint64
	Currency                                               Currency
	Recipient, Desc, Statement, Bank, Card, SourceTx, Dest string
	SourceType                                             TransferSourceType
}

TransferParams is the set of parameters that can be used when creating or updating a transfer. For more details see https://stripe.com/docs/api#create_transfer and https://stripe.com/docs/api#update_transfer.

type TransferSchedule 

type TransferSchedule struct {
	Delay       uint64   `json:"delay_days"`
	Interval    Interval `json:"interval"`
	WeekAnchor  string   `json:"weekly_anchor"`
	MonthAnchor uint64   `json:"monthly_anchor"`
}

TransferSchedule is the structure for an account's transfer schedule.

type TransferScheduleParams 

type TransferScheduleParams struct {
	Delay, MonthAnchor uint64
	WeekAnchor         string
	Interval           Interval
	MinimumDelay       bool
}

TransferScheduleParams are the parameters allowed for transfer schedules.

func (*TransferScheduleParams) AppendDetails 

func (t *TransferScheduleParams) AppendDetails(values *RequestValues)

AppendDetails adds the transfer schedule to the query string.

type TransferSourceType 

type TransferSourceType string

TransferSourceType is the list of allowed values for the transfer's source_type field. Allowed values are "alipay_account", bank_account", "bitcoin_receiver", "card".

type TransferStatus 

type TransferStatus string

TransferStatus is the list of allowed values for the transfer's status. Allowed values are "paid", "pending", "in_transit", "failed", "canceled".

type TransferType 

type TransferType string

TransferType is the list of allowed values for the transfer's type. Allowed values are "bank_account", "card", "stripe_account".

type TxFee 

type TxFee struct {
	Amount      int64    `json:"amount"`
	Currency    Currency `json:"currency"`
	Type        string   `json:"type"`
	Desc        string   `json:"description"`
	Application string   `json:"application"`
}

TxFee is a structure that breaks down the fees in a transaction.

type TxListParams 

type TxListParams struct {
	ListParams
	Created, Available      int64
	Currency, Src, Transfer string
	Type                    TransactionType
}

TxListParams is the set of parameters that can be used when listing balance transactions. For more details see https://stripe.com/docs/api/#balance_history.

type TxParams 

type TxParams struct {
	Params
}

TxParams is the set of parameters that can be used when retrieving a transaction. For more details see https://stripe.com/docs/api#retrieve_balance_transaction.

type Verification 

type Verification string

Verification is the list of allowed verification responses. Allowed values are "pass", "fail", "unchecked", "unavailabe".

type VerificationFieldsList 

type VerificationFieldsList struct {
	AdditionalFields []string `json:"additional"`
	MinimumFields    []string `json:"minimum"`
}

VerificationFieldsList lists the fields needed for an account verification. For more details see https://stripe.com/docs/api#country_spec_object-verification_fields.

Source Files

View all Source files

Directories

Path Synopsis
Package account provides the /account APIs
 Package account provides the /account APIs
Package balance provides the /balance APIs
 Package balance provides the /balance APIs
Package bankaccount provides the /bank_accounts APIs
 Package bankaccount provides the /bank_accounts APIs
Package bitcoinreceiver provides the /bitcoin/receivers APIs.
 Package bitcoinreceiver provides the /bitcoin/receivers APIs.
Package bitcointransaction provides the /bitcoin/transactions APIs.
 Package bitcointransaction provides the /bitcoin/transactions APIs.
Package card provides the /cards APIs
 Package card provides the /cards APIs
Package charge provides the /charges APIs
 Package charge provides the /charges APIs
Package client provides a Stripe client for invoking APIs across all resources
 Package client provides a Stripe client for invoking APIs across all resources
Package countryspec provides the /country_specs APIs
 Package countryspec provides the /country_specs APIs
Package coupon provides the /coupons APIs
 Package coupon provides the /coupons APIs
Package currency provides the list of currency codes
 Package currency provides the list of currency codes
Package customer provides the /customers APIs
 Package customer provides the /customers APIs
Package discount provides the discount-related APIs
 Package discount provides the discount-related APIs
Package dispute provides the dispute-related APIs
 Package dispute provides the dispute-related APIs
Package event provides the /events APIs
 Package event provides the /events APIs
Package fee provides the /application_fees APIs
 Package fee provides the /application_fees APIs
Package feerefund provides the /application_fees/refunds APIs
 Package feerefund provides the /application_fees/refunds APIs
Package fileupload provides the file upload related APIs
 Package fileupload provides the file upload related APIs
Package invoice provides the /invoices APIs
 Package invoice provides the /invoices APIs
Package invoiceitem provides the /invoiceitems APIs
 Package invoiceitem provides the /invoiceitems APIs
Package paymentsource provides the /sources APIs
 Package paymentsource provides the /sources APIs
Package plan provides the /plans APIs
 Package plan provides the /plans APIs
Package recipient provides the /recipients APIs
 Package recipient provides the /recipients APIs
Package refund provides the /refunds APIs
 Package refund provides the /refunds APIs
Package reversal provides the /transfers/reversals APIs
 Package reversal provides the /transfers/reversals APIs
Package sub provides the /subscriptions APIs
 Package sub provides the /subscriptions APIs
Package token provides the /tokens APIs
 Package token provides the /tokens APIs
Package transfer provides the /transfers APIs
 Package transfer provides the /transfers APIs
Package utils provides internal utilities
 Package utils provides internal utilities

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.