### Fetch Baseball Leagues using Shell Httpie

Source: https://api-sports.io/documentation/baseball/v1/index

Illustrates how to make a GET request to the API-SPORTS Baseball API v1 using the Httpie command-line tool. This example shows the syntax for specifying the method, URL, and custom headers. Requires Httpie to be installed.

```shell
http --follow --timeout 3600 GET 'https://v1.baseball.api-sports.io/leagues' \
 x-apisports-key:'XxXxXxXxXxXxXxXxXxXxXxXx' \

```

--------------------------------

### Fetch Leagues Data using Shell

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Shell. Requires an API key and replaces `{endpoint}` with 'leagues'. Demonstrates using 'curl' for making GET requests.

```bash
curl -X GET "https://v1.baseball.api-sports.io/leagues" -H "x-apisports-key: XxXxXxXxXxXxXxXxXxXxXx"
```

--------------------------------

### Node.js: Fetch Baseball Leagues using Requests

Source: https://api-sports.io/documentation/baseball/v1/index

This example demonstrates fetching baseball league data using the 'request' library in Node.js. It configures a GET request with the necessary API key in the headers and logs the response body.

```javascript
var request = require('request');
var options = {
  'method': 'GET',
  'url': 'https://v1.baseball.api-sports.io/leagues',
  'headers': {
    'x-apisports-key': 'XxXxXxXxXxXxXxXxXxXxXxXx',
  }
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

```

--------------------------------

### Fetch Leagues Data using C++

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using C++. Requires an API key and replaces `{endpoint}` with 'leagues'. This example uses 'libcurl' for making HTTP requests.

```cpp
#include <iostream>
#include <curl/curl.h>

int main() {
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://v1.baseball.api-sports.io/leagues");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, "x-apisports-key: XxXxXxXxXxXxXxXxXxXxXx");
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    return 0;
}

```

--------------------------------

### Get Baseball Leagues using cURL

Source: https://api-sports.io/documentation/baseball/v1/index

This example demonstrates how to fetch league data using the cURL command-line tool. It specifies the GET request method, the API endpoint URL, and includes the required 'x-apisports-key' header.

```bash
curl --request GET \
    --url https://v1.baseball.api-sports.io/leagues \
    --header 'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx'

```

--------------------------------

### Get Baseball Leagues using Javascript Fetch API

Source: https://api-sports.io/documentation/baseball/v1/index

This Javascript example uses the Fetch API to retrieve league data. It defines headers including the API key, configures request options for a GET method, and then makes the fetch call. The response is processed to text, and the result is logged to the console, with basic error handling. This requires a browser environment or a Node.js environment with a fetch polyfill.

```javascript
var myHeaders = new Headers();
myHeaders.append("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXxXx");

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

fetch("https://v1.baseball.api-sports.io/leagues", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


```

--------------------------------

### Fetch Leagues Data using cURL

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using cURL. Requires an API key and replaces `{endpoint}` with 'leagues'. Demonstrates the command-line usage for making GET requests.

```bash
curl --location --request GET 'https://v1.baseball.api-sports.io/leagues'
--header 'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXx'
```

--------------------------------

### Custom Translations Example with data-custom-lang

Source: https://api-sports.io/documentation/baseball/v1/index

Demonstrates the usage of both 'data-lang' and 'data-custom-lang' attributes to load custom translations for api-sports-widgets. This example sets the language to 'custom' and points to a custom JSON translation file.

```html
<api-sports-widget data-type="games" data-target-game="modal"></api-sports-widget>

<api-sports-widget
  data-type="config"
  data-key="Your-Api-Key-Here"
  data-sport="football"
  data-lang="custom"
  data-custom-lang="https://yourdomain.com/lang/custom.json"
></api-sports-widget>
```

--------------------------------

### Get Baseball Leagues using C and libcurl

Source: https://api-sports.io/documentation/baseball/v1/index

This C code snippet uses the libcurl library to make a GET request to the API Sports Baseball v1 leagues endpoint. It sets up a curl handle, specifies the URL, adds the custom request method and headers, and performs the request. Ensure libcurl is installed and linked.

```c
CURL *curl;
CURLcode res;
c_url = curl_easy_init();
if(curl) {
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
  curl_easy_setopt(curl, CURLOPT_URL, "https://v1.baseball.api-sports.io/leagues");
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  res = curl_easy_perform(curl);
}
c_url_easy_cleanup(curl);

```

--------------------------------

### PHP: Fetch Baseball Leagues using cURL

Source: https://api-sports.io/documentation/baseball/v1/index

This PHP example uses the cURL extension to fetch baseball league data. It configures a GET request with the API key in the HTTP headers and returns the response.

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://v1.baseball.api-sports.io/leagues',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => array(
    'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx',
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

```

--------------------------------

### Fetch Baseball Leagues using Python Requests

Source: https://api-sports.io/documentation/baseball/v1/index

Provides an example of fetching baseball league data using the popular 'Requests' library in Python. This approach simplifies HTTP requests by abstracting away much of the lower-level connection handling. Requires the 'requests' library to be installed.

```python
import requests

url = "https://v1.baseball.api-sports.io/leagues"

payload={}
headers = {
  'x-apisports-key': 'XxXxXxXxXxXxXxXxXxXxXxXx',
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

```

--------------------------------

### Fetch Leagues Data using JavaScript

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using JavaScript. Requires an API key and replaces `{endpoint}` with 'leagues'. Assumes a 'get' function is defined for making HTTP requests.

```javascript
get("https://v1.baseball.api-sports.io/leagues", {
    "x-apisports-key": "XxXxXxXxXxXxXxXxXxXxXx"
});
```

--------------------------------

### PHP: Fetch Baseball Leagues using Http

Source: https://api-sports.io/documentation/baseball/v1/index

This PHP example uses the http library to make a GET request to retrieve baseball league data. It configures the request URL and headers, including the API key, and then outputs the response body.

```php
$client = new http\Client;
$request = new http\Client\Request;
$request->setRequestUrl('https://v1.baseball.api-sports.io/leagues');
$request->setRequestMethod('GET');
$request->setHeaders(array(
    'x-apisports-key' => 'XxXxXxXxXxXxXxXxXxXxXxXx'
));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();

```

--------------------------------

### Objective-C: Fetch Baseball Leagues using NSURLSession

Source: https://api-sports.io/documentation/baseball/v1/index

Provides an Objective-C example for fetching baseball league data using NSURLSession. It configures an NSMutableURLRequest with the API key and makes a GET request. The response data is parsed as JSON and logged.

```objectivec
#import <Foundation/Foundation.h>

dispatch_semaphore_t sema = dispatch_semaphore_create(0);

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://v1.baseball.api-sports.io/leagues"]
  cachePolicy:NSURLRequestUseProtocolCachePolicy
  timeoutInterval:10.0];
NSDictionary *headers = @{
  @"x-apisports-key": @"XxXxXxXxXxXxXxXxXxXxXxXx",
};

[request setAllHTTPHeaderFields:headers];

[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
  if (error) {
    NSLog(@"%@", error);
    dispatch_semaphore_signal(sema);
  } else {
    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
    NSError *parseError = nil;
    NSDictionary *responseDictionary = [NSJSONSerialization JSONObjectWithData:data options:0 error:&parseError];
    NSLog(@"%@",responseDictionary);
    dispatch_semaphore_signal(sema);
  }
}];
[dataTask resume];
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

```

--------------------------------

### Get Baseball Leagues using Go and Native HTTP

Source: https://api-sports.io/documentation/baseball/v1/index

This Go program uses the built-in 'net/http' package to retrieve league data. It constructs a GET request, adds the necessary API key header, executes the request using a default HTTP client, reads the response body, and prints it to the console. Error handling is included for request creation and response processing.

```go
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://v1.baseball.api-sports.io/leagues"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXxXx")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}


```

--------------------------------

### HTML Widget Integration

Source: https://api-sports.io/documentation/baseball/v1/index

Demonstrates how to integrate api-sports-widget elements into an HTML page. Includes examples for a general widget, a game container, and a configuration widget with a custom theme.

```html
<api-sports-widget data-type="games"></api-sports-widget>

<div id="game-container"></div>

<api-sports-widget
  data-type="config"
  data-key="Your-Api-Key-Here"
  data-sport="football"
  data-theme="MyTheme"
></api-sports-widget>

```

--------------------------------

### GET /leagues

Source: https://api-sports.io/documentation/baseball/v1/index

Retrieves a list of available leagues and cups.

```APIDOC
## GET /leagues

### Description
Get the list of available leagues and cups. League IDs are unique and persist across seasons. You can find all league IDs on the API Dashboard. Most parameters can be used together.

### Method
GET

### Endpoint
`https://v1.baseball.api-sports.io/leagues`

### Parameters
#### Query Parameters
- **id** (integer) - The ID of the league.
- **name** (string) - The name of the league.
- **country_id** (integer) - The ID of the country.
- **country** (string) - The name of the country.
- **type** (string) - Enum: "league" "cup". The type of the league.
- **season** (integer) - The season of the league (4 characters).
- **search** (string) - Search term (minimum 3 characters).

#### Header Parameters
- **x-apisports-key** (string) - Required - Your API-SPORTS Key

### Request Example
```bash
curl --location --request GET 'https://v1.baseball.api-sports.io/leagues?season=2020' \
--header 'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx'
```

### Response
#### Success Response (200)
- **get** (string) - The endpoint name.
- **parameters** (object) - Contains the query parameters used for the request.
  - **id** (string) - The league ID.
  - **season** (string) - The season.
- **errors** (array) - An array of errors, if any.
- **results** (integer) - The number of results returned.
- **response** (array) - An array of league objects.
  - **id** (integer) - The unique identifier for the league.
  - **name** (string) - The name of the league.
  - **type** (string) - The type of the league (e.g., "League", "Cup").
  - **logo** (string|null) - The URL of the league logo.
  - **country** (object) - Information about the country the league belongs to.
    - **id** (integer) - The country ID.
    - **name** (string) - The country name.
    - **code** (string) - The country code.
    - **flag** (string) - The URL of the country flag.
  - **seasons** (array) - An array of season objects for the league.
    - **season** (integer) - The year of the season.
    - **current** (boolean) - Indicates if this is the current season.
    - **start** (string) - The start date of the season.
    - **end** (string) - The end date of the season.

#### Response Example
```json
{
  "get": "leagues",
  "parameters": {
    "id": "1",
    "season": "2020"
  },
  "errors": [],
  "results": 1,
  "response": [
    {
      "id": 1,
      "name": "MLB",
      "type": "League",
      "logo": null,
      "country": {
        "id": 1,
        "name": "USA",
        "code": "US",
        "flag": "https://media.api-sports.io/flags/us.svg"
      },
      "seasons": [
        {
          "season": 2020,
          "current": true,
          "start": "2020-02-21",
          "end": "2020-09-03"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### GET /leagues

Source: https://api-sports.io/documentation/baseball/v1/index

Retrieves a list of available baseball leagues.

```APIDOC
## GET /leagues

### Description
Retrieves a list of available baseball leagues.

### Method
GET

### Endpoint
https://v1.baseball.api-sports.io/leagues

### Parameters
#### Headers
- **x-apisports-key** (string) - Required - Your API key for authentication.

### Request Example
```json
{
  "message": "This is a GET request example. No request body is typically needed for GET requests."
}
```

### Response
#### Success Response (200)
- **response** (object) - Contains a list of leagues.
  - **league_id** (integer) - The unique identifier for the league.
  - **name** (string) - The name of the league.
  - **type** (string) - The type of league (e.g., regular season, playoffs).

#### Response Example
```json
{
  "get": "leagues",
  "parameters": [],
  "errors": [],
  "results": 1,
  "response": [
    {
      "league": {
        "id": 1,
        "name": "Major League Baseball",
        "type": null,
        "season": "2023"
      },
      "country": {
        "name": "United States",
        "code": "US",
        "flag": "https://media.api-sports.io/flags/us.svg"
      },
      "all_seasons": [
        {
          "season": 2023,
          "start": "2023-03-30",
          "end": "2023-11-02"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### Get Baseball Leagues using Java and Unirest

Source: https://api-sports.io/documentation/baseball/v1/index

This Java code snippet uses the Unirest library to fetch league data. It configures timeouts, sends a GET request to the specified URL, and includes the 'x-apisports-key' header. The response is then obtained as a String. Ensure Unirest is included in your project dependencies.

```java
Unirest.setTimeouts(0, 0);
HttpResponse<String> response = Unirest.get("https://v1.baseball.api-sports.io/leagues")
  .header("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXxXx")
  .asString();


```

--------------------------------

### GET /countries

Source: https://api-sports.io/documentation/baseball/v1/index

Retrieves a list of countries available in the API.

```APIDOC
## GET /countries

### Description
Retrieves a list of countries. Each country has a unique ID, name, code, and a flag URL.

### Method
GET

### Endpoint
`https://v1.baseball.api-sports.io/countries`

### Parameters
#### Header Parameters
- **x-apisports-key** (string) - Required - Your API-SPORTS Key

### Request Example
```bash
curl --location --request GET 'https://v1.baseball.api-sports.io/countries' \
--header 'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx'
```

### Response
#### Success Response (200)
- **get** (string) - The endpoint name.
- **parameters** (object) - Contains the query parameters used for the request.
  - **code** (string) - The country code.
- **errors** (array) - An array of errors, if any.
- **results** (integer) - The number of results returned.
- **response** (array) - An array of country objects.
  - **id** (integer) - The unique identifier for the country.
  - **name** (string) - The name of the country.
  - **code** (string) - The country code (e.g., 'US').
  - **flag** (string) - The URL of the country's flag.

#### Response Example
```json
{
  "get": "countries",
  "parameters": {
    "code": "us"
  },
  "errors": [],
  "results": 1,
  "response": [
    {
      "id": 1,
      "name": "USA",
      "code": "US",
      "flag": "https://media.api-sports.io/flags/us.svg"
    }
  ]
}
```
```

--------------------------------

### Get Baseball Leagues using Dart and http

Source: https://api-sports.io/documentation/baseball/v1/index

This Dart code snippet uses the 'http' package to make a GET request for league information. It defines headers including the API key, creates an HTTP request object, adds headers, sends the request, and prints the response body if successful or the reason phrase if an error occurs. Ensure the 'http' package is included in your pubspec.yaml.

```dart
var headers = {
  'x-apisports-key': 'XxXxXxXxXxXxXxXxXxXxXxXx',
};
var request = http.Request('GET', Uri.parse('https://v1.baseball.api-sports.io/leagues'));

request.headers.addAll(headers);

http.StreamedResponse response = await request.send();

if (response.statusCode == 200) {
  print(await response.stream.bytesToString());
}
else {
  print(response.reasonPhrase);
}


```

--------------------------------

### GET /games

Source: https://api-sports.io/documentation/baseball/v1/index

Retrieves game information based on various query parameters. Requires an API-SPORTS key.

```APIDOC
## GET /games

### Description
Retrieves game information for a specific game ID, date, league, season, team, or timezone. This endpoint provides detailed data about baseball games.

### Method
GET

### Endpoint
https://v1.baseball.api-sports.io/games

### Parameters
#### Query Parameters
- **id** (integer) - Optional - The ID of the game.
- **date** (string) - Optional - A valid date (e.g., 'YYYY-MM-DD').
- **league** (integer) - Optional - The ID of the league.
- **season** (integer) - Optional - The season year (4 characters).
- **team** (integer) - Optional - The ID of the team.
- **timezone** (string) - Optional - A valid timezone (e.g., 'Europe/London').

*Note: This endpoint requires at least one query parameter.*

#### Header Parameters
- **x-apisports-key** (string) - Required - Your API-SPORTS Key

### Request Example
```bash
curl -X GET \
  'https://v1.baseball.api-sports.io/games?id=59647' \
  -H 'x-apisports-key: YOUR_API_KEY'
```

### Response
#### Success Response (200)
- **get** (string) - The endpoint called.
- **parameters** (object) - The parameters used for the request.
- **errors** (array) - An array of errors, if any.
- **results** (integer) - The number of results returned.
- **response** (array) - An array of game objects, each containing detailed game information.
  - **id** (integer) - Game ID.
  - **date** (string) - Game date and time.
  - **time** (string) - Game time.
  - **timestamp** (integer) - Game timestamp.
  - **timezone** (string) - Game timezone.
  - **week** (string/null) - Game week.
  - **status** (object) - Game status details.
    - **long** (string) - Long status description (e.g., 'Finished').
    - **short** (string) - Short status code (e.g., 'FT').
  - **country** (object) - Country information.
  - **league** (object) - League information.
  - **teams** (object) - Home and Away team details.
  - **scores** (object) - Score details for home and away teams.

#### Response Example
```json
{
  "get": "games",
  "parameters": {
    "id": "1"
  },
  "errors": [],
  "results": 1,
  "response": [
    {
      "id": 1,
      "date": "2020-02-21T18:05:00+00:00",
      "time": "18:05",
      "timestamp": 1582308300,
      "timezone": "UTC",
      "week": null,
      "status": {
        "long": "Finished",
        "short": "FT"
      },
      "country": {
        "id": 1,
        "name": "USA",
        "code": "US",
        "flag": "https://media.api-sports.io/flags/us.svg"
      },
      "league": {
        "id": 1,
        "name": "MLB",
        "type": "League",
        "logo": "https://media.api-sports.io/baseball/leagues/1.png",
        "season": 2020
      },
      "teams": {
        "home": {
          "id": 5,
          "name": "Boston Red Sox",
          "logo": "https://media.api-sports.io/baseball/teams/5.png"
        },
        "away": {
          "id": 43,
          "name": "Northeastern",
          "logo": "https://media.api-sports.io/baseball/teams/43.png"
        }
      },
      "scores": {
        "home": {
          "hits": 6,
          "errors": 2,
          "innings": {
            "1": 0,
            "2": 0,
            "3": 0,
            "4": 0,
            "5": 0,
            "6": 3,
            "7": null,
            "8": null,
            "9": null,
            "extra": null
          },
          "total": 3
        },
        "away": {
          "hits": 4,
          "errors": 0,
          "innings": {
            "1": 0,
            "2": 0,
            "3": 0,
            "4": 0,
            "5": 0,
            "6": 0,
            "7": 0,
            "8": null,
            "9": null,
            "extra": null
          },
          "total": 0
        }
      }
    }
  ]
}
```
```

--------------------------------

### OCaml: Fetch Baseball Leagues using Cohttp

Source: https://api-sports.io/documentation/baseball/v1/index

This OCaml snippet demonstrates fetching baseball league data using the Cohttp library. It constructs a GET request with the necessary headers and prints the response body as a string.

```ocaml
open Lwt
open Cohttp
open Cohttp_lwt_unix;

let reqBody =
  let uri = Uri.of_string "https://v1.baseball.api-sports.io/leagues" in
  let headers = Header.init ()
    |> fun h -> Header.add h "x-apisports-key" "XxXxXxXxXxXxXxXxXxXxXxXx"
  in
  Client.call ~headers `GET uri >>= fun (_resp, body) ->
  body |> Cohttp_lwt.Body.to_string >|= fun body -> body

let () =
  let respBody = Lwt_main.run reqBody in
  print_endline (respBody)

```

--------------------------------

### Fetch Baseball Leagues using Ruby Net::HTTP

Source: https://api-sports.io/documentation/baseball/v1/index

Demonstrates how to access baseball league data from the API-SPORTS Baseball API v1 using Ruby's Net::HTTP library. This example covers setting up the URL, establishing an SSL connection, adding the required API key header, and retrieving the response body. Requires Ruby.

```ruby
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://v1.baseball.api-sports.io/leagues")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["x-apisports-key"] = 'XxXxXxXxXxXxXxXxXxXxXxXx'

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

```

--------------------------------

### Fetch Leagues Data using OCaml

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using OCaml. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'Cohttp_lwt_unix' library for making HTTP requests.

```ocaml
open Lwt.Infix

let fetch_leagues () = 
  let headers = Cohttp.Header.of_list ["x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXx"]
  in
  Cohttp_lwt_unix.Client.get ~headers "https://v1.baseball.api-sports.io/leagues" 
  >>= fun (resp, body) ->
  let status = Cohttp.Response.status resp in
  Cohttp.Body.to_string body >|= fun body_str ->
  (status, body_str)

let () = 
  match Lwt_main.run (fetch_leagues ()) with
  | (status, body) -> Printf.printf "Status: %s\nBody: %s\n" (Cohttp.Code.string_of_status status) body

```

--------------------------------

### Fetch Baseball Leagues using Shell wget

Source: https://api-sports.io/documentation/baseball/v1/index

Provides a command-line example using wget to retrieve baseball league data from the API-SPORTS Baseball API v1. It highlights options for disabling certificate checks, setting timeouts, specifying the HTTP method, and including custom headers. Requires wget.

```shell
wget --no-check-certificate --quiet \
  --method GET \
  --timeout=0 \
  --header 'x-apisports-key: XxXxXxXxXxXxXxXxXxXxXxXx' \
   'https://v1.baseball.api-sports.io/leagues'

```

--------------------------------

### Fetch Baseball Leagues using Swift URLSession

Source: https://api-sports.io/documentation/baseball/v1/index

Demonstrates how to fetch baseball league data using Swift's URLSession framework. This example covers creating a URL request, adding the necessary API key header, setting the HTTP method, and handling the response data asynchronously. Requires Swift and Foundation framework.

```swift
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

var semaphore = DispatchSemaphore (value: 0)

var request = URLRequest(url: URL(string: "https://v1.baseball.api-sports.io/leagues")!,timeoutInterval: Double.infinity)
request.addValue("XxXxXxXxXxXxXxXxXxXxXxXx", forHTTPHeaderField: "x-apisports-key")

request.httpMethod = "GET"

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    semaphore.signal()
    return
  }
  print(String(data: data, encoding: .utf8)!)
  semaphore.signal()
}

task.resume()
semaphore.wait()


```

--------------------------------

### Fetch Leagues Data using Go

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Go. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the standard 'net/http' package for making HTTP requests.

```go
package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {

	client := &http.Client{}
	req, err := http.NewRequest("GET", "https://v1.baseball.api-sports.io/leagues", nil)

	if err != nil {
		fmt.Print(err)
	}
	req.Header.Add("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXx")

	res, err := client.Do(req)
	if err != nil {
		fmt.Print(err)
	}
	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Print(err)
	}
	fmt.Print(string(body))
}

```

--------------------------------

### Fetch Leagues Data using C#

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using C#. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses 'HttpClient' for making HTTP requests.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Example
{
    public static async Task Main() {
        using var client = new HttpClient();
        var request = new HttpRequestMessage
        {
            Method = HttpMethod.Get,
            RequestUri = new Uri("https://v1.baseball.api-sports.io/leagues"),
            Headers = {
                { "x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXx" },
            }
        };
        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();
        var body = await response.Content.ReadAsStringAsync();
        Console.WriteLine(body);
    }
}

```

--------------------------------

### Fetch Leagues Data using Swift

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Swift. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses 'URLSession' for making HTTP requests.

```swift
import Foundation

func fetchLeagues() {
    guard let url = URL(string: "https://v1.baseball.api-sports.io/leagues") else { return }
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue("XxXxXxXxXxXxXxXxXxXxXx", forHTTPHeaderField: "x-apisports-key")

    URLSession.shared.dataTask(with: request) { data, response, error in
        guard let data = data else { return }
        let responseString = String(data: data, encoding: .utf8)
        print(responseString ?? "")
    }.resume()
}

fetchLeagues()
// To keep the program running until the network request completes in a command-line tool:
RunLoop.main.run() 

```

--------------------------------

### Fetch Leagues Data using Java

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Java. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'OkHttp' client for making HTTP requests.

```java
OkHttpClient client = new OkHttpClient().newBuilder().build();
Request request = new Request.Builder()
  .url("https://v1.baseball.api-sports.io/leagues")
  .addHeader("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXx")
  .method("GET", null)
  .build();
Response response = client.newCall(request).execute();
System.out.println(response.body().string());

```

--------------------------------

### Get Baseball Leagues using C# and RestSharp

Source: https://api-sports.io/documentation/baseball/v1/index

This C# code snippet utilizes the RestSharp library to perform a GET request to retrieve league data. It initializes a RestClient with the API endpoint, sets a timeout, creates a GET request, adds the necessary API key header, and executes the request, printing the response content. Ensure RestSharp is added as a NuGet package.

```csharp
var client = new RestClient("https://v1.baseball.api-sports.io/leagues");
client.Timeout = -1;
var request = new RestRequest(Method.GET);
request.AddHeader("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXxXx");
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);

```

--------------------------------

### Fetch Leagues Data using PowerShell

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using PowerShell. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'Invoke-RestMethod' cmdlet for making HTTP requests.

```powershell
Invoke-RestMethod -Method Get -Uri 'https://v1.baseball.api-sports.io/leagues' -Headers @{'x-apisports-key'='XxXxXxXxXxXxXxXxXxXxXx'}
```

--------------------------------

### Fetch Leagues Data using Objective-C

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Objective-C. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses 'NSURLSession' for making HTTP requests.

```objectivec
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURLSession *session = [NSURLSession sharedSession];
        NSURL *URL = [NSURL URLWithString:@"https://v1.baseball.api-sports.io/leagues"];
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:URL cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:60.0];
        [request setHTTPMethod:@"GET"];
        [request setValue:@"XxXxXxXxXxXxXxXxXxXxXx" forHTTPHeaderField:@"x-apisports-key"];
        
        NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            if (error) {
                NSLog(@"Error: %@\n", error.localizedDescription);
            } else {
                NSString *dataString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
                NSLog(@"%@\n", dataString);
            }
        }];
        [dataTask resume];
        
        // Keep the main thread alive to allow the network request to complete
        CFRunLoopRun(); 
    }
    return 0;
}

```

--------------------------------

### Get Baseball Standings Stages - JSON Response Sample

Source: https://api-sports.io/documentation/baseball/v1/index

This is a sample JSON response for the 'get standings/stages' endpoint. It lists the available stages for a specified league and season, which can be used to filter standings data. The response contains a 'results' count and an array of stage names.

```json
{
  "get": "standings/stages",
  "parameters": {
    "league": "1",
    "season": "2020"
  },
  "errors": [],
  "results": 2,
  "response": [
    "MLB - Regular Season",
    "MLB - Pre-season"
  ]
}
```

--------------------------------

### Get Baseball Standings - JSON Response Sample

Source: https://api-sports.io/documentation/baseball/v1/index

This is a sample JSON response for the 'get standings' endpoint. It includes details about team positions, league information, game statistics, and points for a given league and season. The response structure allows for multiple stages and groups within the standings.

```json
{
  "get": "standings",
  "parameters": {
    "league": "1",
    "season": "2020",
    "team": "5"
  },
  "errors": [],
  "results": 2,
  "response": [
    [
      {
        "position": 12,
        "stage": "MLB - Regular Season",
        "group": {
          "name": "American League"
        },
        "team": {
          "id": 5,
          "name": "Boston Red Sox",
          "logo": "https://media.api-sports.io/baseball/teams/5.png"
        },
        "league": {
          "id": 1,
          "name": "MLB",
          "type": "League",
          "logo": "https://media.api-sports.io/baseball/leagues/1.png",
          "season": 2020
        },
        "country": {
          "id": 1,
          "name": "USA",
          "code": "US",
          "flag": "https://media.api-sports.io/flags/us.svg"
        },
        "games": {
          "played": 0,
          "win": {
            "total": 0,
            "percentage": "0.000"
          },
          "lose": {
            "total": 0,
            "percentage": "0.000"
          }
        },
        "points": {
          "for": 0,
          "against": 0
        },
        "form": null,
        "description": null
      },
      {
        "position": 5,
        "stage": "MLB - Regular Season",
        "group": {
          "name": "AL East"
        },
        "team": {
          "id": 5,
          "name": "Boston Red Sox",
          "logo": "https://media.api-sports.io/baseball/teams/5.png"
        },
        "league": {
          "id": 1,
          "name": "MLB",
          "type": "League",
          "logo": "https://media.api-sports.io/baseball/leagues/1.png",
          "season": 2020
        },
        "country": {
          "id": 1,
          "name": "USA",
          "code": "US",
          "flag": "https://media.api-sports.io/flags/us.svg"
        },
        "games": {
          "played": 0,
          "win": {
            "total": 0,
            "percentage": "0.000"
          },
          "lose": {
            "total": 0,
            "percentage": "0.000"
          }
        },
        "points": {
          "for": 0,
          "against": 0
        },
        "form": null,
        "description": null
      }
    ],
    [
      {
        "position": 9,
        "stage": "MLB - Pre-season",
        "group": {
          "name": "American League"
        },
        "team": {
          "id": 5,
          "name": "Boston Red Sox",
          "logo": "https://media.api-sports.io/baseball/teams/5.png"
        },
        "league": {
          "id": 1,
          "name": "MLB",
          "type": "League",
          "logo": "https://media.api-sports.io/baseball/leagues/1.png",
          "season": 2020
        },
        "country": {
          "id": 1,
          "name": "USA",
          "code": "US",
          "flag": "https://media.api-sports.io/flags/us.svg"
        },
        "games": {
          "played": 12,
          "win": {
            "total": 5,
            "percentage": "0.417"
          },
          "lose": {
            "total": 7,
            "percentage": "0.583"
          }
        },
        "points": {
          "for": 57,
          "against": 60
        },
        "form": null,
        "description": null
      }
    ]
  ]
}
```

--------------------------------

### Fetch Leagues Data using Node.js

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Node.js. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'request' library for making HTTP calls.

```javascript
var unirest = require("unirest");

unirest("GET", "https://v1.baseball.api-sports.io/leagues")
.headers({
  "x-apisports-key": "XxXxXxXxXxXxXxXxXxXxXx"
})
.end(function (res) {
  if (res.error) throw new Error(res.error);
  console.log(res.body);
});
```

--------------------------------

### Fetch Leagues Data using Ruby

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Ruby. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'httparty' gem for making HTTP calls.

```ruby
require 'httparty'

response = HTTParty.get('https://v1.baseball.api-sports.io/leagues', headers: { 'x-apisports-key' => 'XxXxXxXxXxXxXxXxXxXxXx' })

puts response.body
```

--------------------------------

### Get Baseball Leagues using Javascript XHR

Source: https://api-sports.io/documentation/baseball/v1/index

No description

```javascript
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://v1.baseball.api-sports.io/leagues");
xhr.setRequestHeader("x-apisports-key", "XxXxXxXxXxXxXxXxXxXxXxXx");

xhr.send();


```

--------------------------------

### Fetch Leagues Data using Python

Source: https://api-sports.io/documentation/baseball/v1/index

Example of how to fetch league data from the API-SPORTS Baseball API using Python. Requires an API key and replaces `{endpoint}` with 'leagues'. Uses the 'requests' library for making HTTP calls.

```python
import requests

headers = {
    'x-apisports-key': "XxXxXxXxXxXxXxXxXxXxXx"
}

response = requests.request("GET", "https://v1.baseball.api-sports.io/leagues", headers=headers)

print(response.text)
```