ethers.js/docs.wrm/api/providers/api-providers.wrm

_section: API Providers @<api-providers>

There are many services which offer a web API for accessing
the Ethereum Blockchain. These Providers allow connecting
to them, which simplifies development, since you do not need
to run your own instance or cluster of Ethereum nodes.

However, this reliance on third-party services can reduce
resilience, security and increase the amount of required trust.
To mitigate these issues, it is recommended you use a
[Default Provider](providers-getDefaultProvider).


_subsection: EtherscanProvider @<EtherscanProvider> @inherit<[[BaseProvider]]> @src<providers:class.EtherscanProvider>

The **EtherscanProvider** is backed by a combination of the various
[Etherscan APIs](link-etherscan-api).

_property: new ethers.providers.EtherscanProvider([ network = "homestead", [ apiKey ] ])
Create a new **EtherscanProvider** connected to //network// with the
optional //apiKey//.

The //network// may be specified as a **string** for a common
network name, a **number** for a common chain ID or a
[Network Object]provider-(network).

If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.
It is highly recommended for production, you register with
[Etherscan](link-etherscan) for your own API key.

_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.

It is highly recommended for production, you register with
[Etherscan](link-etherscan) for your own API key.


_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)
- ``ropsten`` - Ropsten (proof-of-work testnet)
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
- ``goerli`` - G&ouml;rli (clique testnet)
- ``kovan`` - Kovan (proof-of-authority testnet)

_code: Etherscan Examples @lang<javascript>

//_hide: const EtherscanProvider = ethers.providers.EtherscanProvider;
//_hide: const apiKey = "...";

// Connect to mainnet (homestead)
provider = new EtherscanProvider();

// Connect to rinkeby testnet (these are equivalent)
provider = new EtherscanProvider("rinkeby");
provider = new EtherscanProvider(4);

network = ethers.providers.getNetwork("rinkeby");
//_hide: delete network._defaultProvider;
//_log: network

provider = new EtherscanProvider(network);

// Connect to mainnet (homestead) with an API key
provider = new EtherscanProvider(null, apiKey);
provider = new EtherscanProvider("homestead", apiKey);


_property: provider.getHistory(address) => Array<History> @src<providers>
@TODO... Explain


_subsection: InfuraProvider @<InfuraProvider> @INHERIT<[[UrlJsonRpcProvider]]> @src<providers:class.InfuraProvider>

The **InfuraProvider** is backed by the popular [INFURA](link-infura)
Ethereum service.

_property: new ethers.providers.InfuraProvider([ network = "homestead", [ apiKey ] ]) @SRC<providers>
Create a new **InfuraProvider** connected to //network// with
the optional //apiKey//.

The //network// may be specified as a **string** for a common
network name, a **number** for a common chain ID or a
[Network Object]provider-(network).

The //apiKey// can be a **string** Project ID or an **object**
with the properties ``projectId`` and ``projectSecret`` to
specify a [Project Secret](link-infura-secret) which can be used
on non-public sources (like on a server) to further secure your
API access and quotas.

_property: InfuraProvider.getWebSocketProvider([ network [ , apiKey ] ]) => [[WebSocketProvider]] @<InfuraProvider-getWebSocketProvider> @SRC<providers:InfuraProvider.getWebSocketProvider>
Create a new [[WebSocketProvider]] using the INFURA web-socket endpoint
to connect to //network// with the optional //apiKey//.

The //network// and //apiKey// are specified the same as [the constructor](InfuraProvider).

_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.

It is highly recommended for production, you register with
[INFURA](link-infura) for your own API key.

_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)
- ``ropsten`` - Ropsten (proof-of-work testnet)
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
- ``goerli`` - G&ouml;rli (clique testnet)
- ``kovan`` - Kovan (proof-of-authority testnet)
- ``matic`` - Polygon
- ``maticmum`` - Polygon Mumbai Testnet
- ``optimism`` - Optimism (L2; optimistic roll-up)
- ``optimism-kovan`` - Optimism Testnet (L2; optimistic roll-up testnet)
- ``arbitrum`` - Arbitrum (L2; optimistic roll-up)
- ``arbitrum-rinkeby`` - Arbitrum Testnet (L2; optimistic roll-up testnet)

_code: INFURA Examples @lang<javascript>

//_hide: const InfuraProvider = ethers.providers.InfuraProvider;
//_hide: const projectId = "...";
//_hide: const projectSecret = "...";

// Connect to mainnet (homestead)
provider = new InfuraProvider();

// Connect to the ropsten testnet
// (see EtherscanProvider above for other network examples)
provider = new InfuraProvider("ropsten");

// Connect to mainnet with a Project ID (these are equivalent)
provider = new InfuraProvider(null, projectId);
provider = new InfuraProvider("homestead", projectId);

// Connect to mainnet with a Project ID and Project Secret
provider = new InfuraProvider("homestead", {
    projectId: projectId,
    projectSecret: projectSecret
});

// Connect to the INFURA WebSocket endpoints with a WebSocketProvider
provider = InfuraProvider.getWebSocketProvider()
//_hide: await provider.destroy();


_subsection: AlchemyProvider @<AlchemyProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.AlchemyProvider>

The **AlchemyProvider** is backed by [Alchemy](link-alchemy).

_property: new ethers.providers.AlchemyProvider([ network = "homestead", [ apiKey ] ])
Create a new **AlchemyProvider** connected to //network// with
the optional //apiKey//.

The //network// may be specified as a **string** for a common
network name, a **number** for a common chain ID or a
[Network Object](providers-Network).

_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.

It is highly recommended for production, you register with
[Alchemy](link-alchemy) for your own API key.

_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)
- ``ropsten`` - Ropsten (proof-of-work testnet)
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
- ``goerli`` - G&ouml;rli (clique testnet)
- ``kovan`` - Kovan (proof-of-authority testnet)
- ``matic`` - Polygon
- ``maticmum`` - Polygon Mumbai Testnet
- ``optimism`` - Optimism (L2; optimistic roll-up)
- ``optimism-kovan`` - Optimism Testnet (L2; optimistic roll-up testnet)
- ``arbitrum`` - Arbitrum (L2; optimistic roll-up)
- ``arbitrum-rinkeby`` - Arbitrum Testnet (L2; optimistic roll-up testnet)

_code: Alchemy Examples @lang<javascript>

//_hide: const AlchemyProvider = ethers.providers.AlchemyProvider;
//_hide: const apiKey = "...";

// Connect to mainnet (homestead)
provider = new AlchemyProvider();

// Connect to the ropsten testnet
// (see EtherscanProvider above for other network examples)
provider = new AlchemyProvider("ropsten");

// Connect to mainnet with an API key (these are equivalent)
provider = new AlchemyProvider(null, apiKey);
provider = new AlchemyProvider("homestead", apiKey);

// Connect to the Alchemy WebSocket endpoints with a WebSocketProvider
provider = AlchemyProvider.getWebSocketProvider()
//_hide: provider.destroy();


_subsection: CloudflareProvider @<CloudflareProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.CloudflareProvider>

The CloudflareProvider is backed by the [Cloudflare Ethereum Gateway](link-cloudflare).

_property: new ethers.providers.CloudflareProvider()
Create a new **CloudflareProvider** connected to mainnet (i.e. "homestead").

_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)

_code: Cloudflare Examples @lang<javascript>

//_hide: const CloudflareProvider = ethers.providers.CloudflareProvider;

// Connect to mainnet (homestead)
provider = new CloudflareProvider();


_subsection: PocketProvider @<PocketProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.PocketProvider>

The **PocketProvider** is backed by [Pocket](link-pocket).

_property: new ethers.providers.PocketProvider([ network = "homestead", [ apiKey ] ])
Create a new **PocketProvider** connected to //network// with
the optional //apiKey//.

The //network// may be specified as a **string** for a common
network name, a **number** for a common chain ID or a
[Network Object](providers-Network).

_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.

It is highly recommended for production, you register with
[Pocket](link-pocket) for your own API key.

_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)
- ``ropsten`` - Ropsten (proof-of-work testnet)
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
- ``goerli`` - G&ouml;rli (clique testnet)

_code: Pocket Examples @lang<javascript>

//_hide: const PocketProvider = ethers.providers.PocketProvider;
//_hide: const applicationId = "...";
//_hide: const applicationSecretKey = "...";
//_hide: const loadBalancer = true;

// Connect to mainnet (homestead)
provider = new PocketProvider();

// Connect to the ropsten testnet
// (see EtherscanProvider above for other network examples)
provider = new PocketProvider("ropsten");

// Connect to mainnet with an Application ID (these are equivalent)
provider = new PocketProvider(null, applicationId);
provider = new PocketProvider("homestead", applicationId);

// Connect to mainnet with an application ID, application secret
// and specify whether to use the load balances
provider = new PocketProvider("homestead", {
    applicationId: applicationId,
    applicationSecretKey: applicationSecretKey,
    loadBalancer: loadBalancer     // true or false
});


_subsection: AnkrProvider @<AnkrProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.AnkrProvider>

The **AnkrProvider** is backed by [Ankr](link-ankr).

_property: new ethers.providers.AnkrProvider([ network = "homestead", [ apiKey ] ])
Create a new **AnkrProvider** connected to //network// with
the optional //apiKey//.

The //network// may be specified as a **string** for a common
network name, a **number** for a common chain ID or a
[Network Object](providers-Network).

_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.

It is highly recommended for production, you register with
[Ankr](link-ankr) for your own API key.

_definition: **Supported Networks**

- ``homestead`` - Homestead (Mainnet)
- ``matic`` - Polygon
- ``arbitrum`` - Arbitrum (L2; optimistic roll-up)

_code: Ankr Examples @lang<javascript>

//_hide: const AnkrProvider = ethers.providers.AnkrProvider;
//_hide: const apiKey = "...";

// Connect to mainnet (homestead)
provider = new AnkrProvider();

// Connect to polygont
// (see EtherscanProvider above for other network examples)
provider = new AnkrProvider("matic");

// Connect to mainnet with an API Key (these are equivalent)
provider = new AnkrProvider(null, apiKey);
provider = new AnkrProvider("homestead", apiKey);