Add common ways to query as a section in the docs.

[bagelbits]

Add some "Here is how to query the API" in different languages

[ecshreve]

just in case anyone stumbles across this issue and wants to dive in, here's some helpful links to get ya started:

rapidoc example using code samples: https://mrin9.github.io/RapiDoc/examples/code-samples.html#operations-top

the actual file from the rapidoc repo associated with that example: https://github.com/mrin9/RapiDoc/blob/master/docs/examples/code-samples.html

also feel free to DM me or hit up the discord with any questions about rapidoc / docs :)

[paulchrisluke]

hello, I attempted to create a PR for this, but a uncertain which repo I should request access to? Docs?

Anyway, here is a markdown file with some suggested documentation with code examples:

Game on! - Paul Chris Luke (Paladin Oathbreaker)

---
sidebar_position: 3
---

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

# Code Examples

This section provides examples of how to query the D&D 5e SRD API in different programming languages. These examples should help you get started quickly with integrating the API into your projects.

## Basic API Operations

For each language, we'll demonstrate four common operations:
1. Getting the API root
2. Fetching a specific resource (a spell, monster, etc.)
3. Filtering resources with query parameters
4. Handling errors

## Getting the API Root

<Tabs groupId="programming-language">
  <TabItem value="javascript-browser" label="JavaScript (Browser)">
javascript
// Using fetch (modern browsers)
fetch('https://www.dnd5eapi.co/api/')
  .then(response => response.json())
  .then(data => {
    console.log('Available endpoints:', data);
  })
  .catch(error => {
    console.error('Error:', error);
  });

  </TabItem>
  <TabItem value="javascript-node" label="JavaScript (Node.js)">
javascript
const https = require('https');

https.get('https://www.dnd5eapi.co/api/', (response) => {
  let data = '';

  // A chunk of data has been received
  response.on('data', (chunk) => {
    data += chunk;
  });

  // The whole response has been received
  response.on('end', () => {
    const endpoints = JSON.parse(data);
    console.log('Available endpoints:', endpoints);
  });

}).on('error', (error) => {
  console.error('Error:', error);
});

  </TabItem>
  <TabItem value="python" label="Python">
python
import requests

response = requests.get('https://www.dnd5eapi.co/api/')
data = response.json()

print('Available endpoints:')
for endpoint, url in data.items():
    print(f"- {endpoint}")

  </TabItem>
  <TabItem value="curl" label="cURL (Shell)">
bash
curl -s https://www.dnd5eapi.co/api/ | json_pp

  </TabItem>
  <TabItem value="php" label="PHP">
php
<?php
$response = file_get_contents('https://www.dnd5eapi.co/api/');
$data = json_decode($response, true);

echo "Available endpoints:\n";
foreach ($data as $endpoint => $url) {
    echo "- $endpoint\n";
}
?>

  </TabItem>
  <TabItem value="java" label="Java">
java
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;
import org.json.JSONObject;

public class DndApiExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.dnd5eapi.co/api/");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.connect();

            if (conn.getResponseCode() == 200) {
                Scanner scanner = new Scanner(url.openStream());
                String response = scanner.useDelimiter("\\A").next();
                scanner.close();
                
                JSONObject data = new JSONObject(response);
                System.out.println("Available endpoints:");
                for (String key : data.keySet()) {
                    System.out.println("- " + key);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  </TabItem>
  <TabItem value="csharp" label="C#">
csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text.Json;
using System.Collections.Generic;

class DndApiExample
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        try 
        {
            var response = await client.GetStringAsync("https://www.dnd5eapi.co/api/");
            var endpoints = JsonSerializer.Deserialize<Dictionary<string, string>>(response);
            
            Console.WriteLine("Available endpoints:");
            foreach (var endpoint in endpoints)
            {
                Console.WriteLine($"- {endpoint.Key}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

  </TabItem>
  <TabItem value="ruby" label="Ruby">
ruby
require 'net/http'
require 'json'

uri = URI('https://www.dnd5eapi.co/api/')
response = Net::HTTP.get(uri)
data = JSON.parse(response)

puts 'Available endpoints:'
data.each do |endpoint, url|
  puts "- #{endpoint}"
end

  </TabItem>
  <TabItem value="go" label="Go">
go
package main

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

func main() {
	response, err := http.Get("https://www.dnd5eapi.co/api/")
	if err != nil {
		fmt.Printf("Error making request: %s\n", err)
		return
	}
	defer response.Body.Close()

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("Error reading response: %s\n", err)
		return
	}

	var endpoints map[string]string
	if err := json.Unmarshal(body, &endpoints); err != nil {
		fmt.Printf("Error parsing JSON: %s\n", err)
		return
	}

	fmt.Println("Available endpoints:")
	for endpoint, _ := range endpoints {
		fmt.Printf("- %s\n", endpoint)
	}
}

  </TabItem>
</Tabs>

## Fetching a Specific Resource

<Tabs groupId="programming-language">
  <TabItem value="javascript-browser" label="JavaScript (Browser)">
javascript
// Fetch the "Acid Arrow" spell
fetch('https://www.dnd5eapi.co/api/spells/acid-arrow')
  .then(response => response.json())
  .then(spell => {
    console.log('Spell details:', spell);
    console.log('Spell name:', spell.name);
    console.log('Spell level:', spell.level);
    console.log('Spell description:', spell.desc.join('\n'));
  })
  .catch(error => {
    console.error('Error:', error);
  });

  </TabItem>
  <TabItem value="javascript-node" label="JavaScript (Node.js)">
javascript
const https = require('https');

https.get('https://www.dnd5eapi.co/api/monsters/adult-black-dragon', (response) => {
  let data = '';

  response.on('data', (chunk) => {
    data += chunk;
  });

  response.on('end', () => {
    const monster = JSON.parse(data);
    console.log(`Monster: ${monster.name}`);
    console.log(`Challenge Rating: ${monster.challenge_rating}`);
    console.log(`Hit Points: ${monster.hit_points}`);
  });

}).on('error', (error) => {
  console.error('Error:', error);
});

  </TabItem>
  <TabItem value="python" label="Python">
python
import requests

response = requests.get('https://www.dnd5eapi.co/api/classes/barbarian')
barbarian = response.json()

print(f"Class: {barbarian['name']}")
print(f"Hit Die: d{barbarian['hit_die']}")
print("Proficiencies:")
for proficiency in barbarian['proficiencies']:
    print(f"- {proficiency['name']}")

  </TabItem>
  <TabItem value="curl" label="cURL (Shell)">
bash
# Get details for the Fighter class
curl -s https://www.dnd5eapi.co/api/classes/fighter | json_pp

  </TabItem>
  <TabItem value="php" label="PHP">
php
<?php
// Fetch information about a specific spell
$response = file_get_contents('https://www.dnd5eapi.co/api/spells/fireball');
$spell = json_decode($response, true);

echo "Spell: {$spell['name']}\n";
echo "Level: {$spell['level']}\n";
echo "Description:\n";
foreach ($spell['desc'] as $paragraph) {
    echo "  $paragraph\n";
}
?>

  </TabItem>
  <TabItem value="java" label="Java">
java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class DndApiModernExample {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.dnd5eapi.co/api/classes/wizard"))
                .build();
                
            HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
                
            JSONObject wizard = new JSONObject(response.body());
            System.out.println("Class: " + wizard.getString("name"));
            System.out.println("Hit Die: d" + wizard.getInt("hit_die"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  </TabItem>
  <TabItem value="csharp" label="C#">
csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text.Json;

class DndApiExample
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        try 
        {
            var response = await client.GetStringAsync("https://www.dnd5eapi.co/api/equipment/longsword");
            var equipment = JsonSerializer.Deserialize<Equipment>(response);
            
            Console.WriteLine($"Equipment: {equipment.Name}");
            Console.WriteLine($"Category: {equipment.EquipmentCategory.Name}");
            Console.WriteLine($"Cost: {equipment.Cost.Quantity} {equipment.Cost.Unit}");
            if (equipment.Damage != null)
            {
                Console.WriteLine($"Damage: {equipment.Damage.DamageDice} {equipment.Damage.DamageType.Name}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
    
    class Equipment
    {
        public string Name { get; set; }
        public Category EquipmentCategory { get; set; }
        public Cost Cost { get; set; }
        public Damage Damage { get; set; }
    }
    
    class Category
    {
        public string Name { get; set; }
    }
    
    class Cost
    {
        public int Quantity { get; set; }
        public string Unit { get; set; }
    }
    
    class Damage
    {
        public string DamageDice { get; set; }
        public DamageType DamageType { get; set; }
    }
    
    class DamageType
    {
        public string Name { get; set; }
    }
}

  </TabItem>
  <TabItem value="ruby" label="Ruby">
ruby
require 'net/http'
require 'json'

uri = URI('https://www.dnd5eapi.co/api/equipment/club')
response = Net::HTTP.get(uri)
equipment = JSON.parse(response)

puts "Equipment: #{equipment['name']}"
puts "Category: #{equipment['equipment_category']['name']}"
puts "Cost: #{equipment['cost']['quantity']} #{equipment['cost']['unit']}"
puts "Damage: #{equipment['damage']['damage_dice']} #{equipment['damage']['damage_type']['name']}"

  </TabItem>
  <TabItem value="go" label="Go">
go
package main

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

type Race struct {
	Name             string   `json:"name"`
	Speed            int      `json:"speed"`
	AbilityBonuses   []Bonus  `json:"ability_bonuses"`
	Alignment        string   `json:"alignment"`
	Age              string   `json:"age"`
	Size             string   `json:"size"`
	SizeDescription  string   `json:"size_description"`
	Languages        []Language `json:"languages"`
	LanguageDesc     string   `json:"language_desc"`
	Traits           []Trait  `json:"traits"`
}

type Bonus struct {
	AbilityScore struct {
		Name string `json:"name"`
	} `json:"ability_score"`
	Bonus int `json:"bonus"`
}

type Language struct {
	Name string `json:"name"`
}

type Trait struct {
	Name string `json:"name"`
}

func main() {
	response, err := http.Get("https://www.dnd5eapi.co/api/races/elf")
	if err != nil {
		fmt.Printf("Error making request: %s\n", err)
		return
	}
	defer response.Body.Close()

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("Error reading response: %s\n", err)
		return
	}

	var race Race
	if err := json.Unmarshal(body, &race); err != nil {
		fmt.Printf("Error parsing JSON: %s\n", err)
		return
	}

	fmt.Printf("Race: %s\n", race.Name)
	fmt.Printf("Speed: %d\n", race.Speed)
	fmt.Printf("Size: %s\n", race.Size)
	fmt.Printf("Ability Bonuses:\n")
	for _, bonus := range race.AbilityBonuses {
		fmt.Printf("  %s: +%d\n", bonus.AbilityScore.Name, bonus.Bonus)
	}
}

  </TabItem>
</Tabs>

## Filtering Resources

<Tabs groupId="programming-language">
  <TabItem value="javascript-browser" label="JavaScript (Browser)">
javascript
// Get all spells for the Wizard class
fetch('https://www.dnd5eapi.co/api/spells?school=evocation&level=3')
  .then(response => response.json())
  .then(data => {
    console.log('Number of results:', data.count);
    console.log('Filtered spells:', data.results);
  })
  .catch(error => {
    console.error('Error:', error);
  });

  </TabItem>
  <TabItem value="javascript-node" label="JavaScript (Node.js)">
javascript
const axios = require('axios');

// Install axios with: npm install axios
async function fetchClasses() {
  try {
    const response = await axios.get('https://www.dnd5eapi.co/api/classes');
    console.log('Available classes:', response.data.results);
    return response.data;
  } catch (error) {
    console.error('Error fetching classes:', error);
  }
}

fetchClasses();

  </TabItem>
  <TabItem value="python" label="Python">
python
import requests

# Get all equipment of the "weapon" category
response = requests.get('https://www.dnd5eapi.co/api/equipment?equipment_category=weapon')
equipment = response.json()

print(f"Found {equipment['count']} weapons:")
for weapon in equipment['results']:
    print(f"- {weapon['name']}")

  </TabItem>
  <TabItem value="curl" label="cURL (Shell)">
bash
# Get all level 1 Cleric spells
curl -s "https://www.dnd5eapi.co/api/spells?level=1&class=cleric" | json_pp

  </TabItem>
  <TabItem value="php" label="PHP">
php
<?php
$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://www.dnd5eapi.co/api/monsters?challenge_rating=5",
    CURLOPT_RETURNTRANSFER => true,
]);

$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);

if ($err) {
    echo "cURL Error: " . $err;
} else {
    $data = json_decode($response, true);
    echo "Found {$data['count']} monsters with CR 5:\n";
    foreach ($data['results'] as $monster) {
        echo "- {$monster['name']}\n";
    }
}
?>

  </TabItem>
  <TabItem value="java" label="Java">
java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONArray;
import org.json.JSONObject;

public class DndApiFilterExample {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.dnd5eapi.co/api/spells?level=0&class=bard"))
                .build();
                
            HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
                
            JSONObject data = new JSONObject(response.body());
            int count = data.getInt("count");
            JSONArray results = data.getJSONArray("results");
            
            System.out.println("Found " + count + " cantrips for bard:");
            for (int i = 0; i < results.length(); i++) {
                JSONObject spell = results.getJSONObject(i);
                System.out.println("- " + spell.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  </TabItem>
  <TabItem value="csharp" label="C#">
csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text.Json;
using System.Collections.Generic;

class DndApiFilterExample
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        try 
        {
            // Filter for heavy armor
            var response = await client.GetStringAsync("https://www.dnd5eapi.co/api/equipment?equipment_category=armor&armor_category=heavy");
            var armor = JsonSerializer.Deserialize<ApiResponse>(response);
            
            Console.WriteLine($"Found {armor.Count} heavy armor items:");
            foreach (var item in armor.Results)
            {
                Console.WriteLine($"- {item.Name}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

// Data classes for deserialization
class ApiResponse
{
    public int Count { get; set; }
    public List<ApiResult> Results { get; set; }
}

class ApiResult
{
    public string Index { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }
}

  </TabItem>
  <TabItem value="ruby" label="Ruby">
ruby
require 'net/http'
require 'json'

# Get all monsters of CR 1
uri = URI('https://www.dnd5eapi.co/api/monsters?challenge_rating=1')
response = Net::HTTP.get(uri)
data = JSON.parse(response)

puts "Found #{data['count']} monsters with CR 1:"
data['results'].each do |monster|
  puts "- #{monster['name']}"
end

  </TabItem>
  <TabItem value="go" label="Go">
go
package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
)

type ApiResponse struct {
	Count   int        `json:"count"`
	Results []ApiEntry `json:"results"`
}

type ApiEntry struct {
	Index string `json:"index"`
	Name  string `json:"name"`
	URL   string `json:"url"`
}

func main() {
	// Get all available spells
	baseURL := "https://www.dnd5eapi.co/api/spells"
	
	params := url.Values{}
	params.Add("level", "9")
	
	requestURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
	response, err := http.Get(requestURL)
	if err != nil {
		fmt.Printf("Error making request: %s\n", err)
		return
	}
	defer response.Body.Close()

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("Error reading response: %s\n", err)
		return
	}

	var apiResponse ApiResponse
	if err := json.Unmarshal(body, &apiResponse); err != nil {
		fmt.Printf("Error parsing JSON: %s\n", err)
		return
	}

	fmt.Printf("Found %d level 9 spells:\n", apiResponse.Count)
	for _, spell := range apiResponse.Results {
		fmt.Printf("- %s\n", spell.Name)
	}
}

  </TabItem>
</Tabs>

## Error Handling

<Tabs groupId="programming-language">
  <TabItem value="javascript-browser" label="JavaScript (Browser)">
javascript
// Try to fetch a non-existent resource
fetch('https://www.dnd5eapi.co/api/spells/not-a-real-spell')
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => {
    console.log('Spell details:', data);
  })
  .catch(error => {
    console.error('Error occurred:', error);
    // Handle the error appropriately in your application
  });

  </TabItem>
  <TabItem value="javascript-node" label="JavaScript (Node.js)">
javascript
const https = require('https');

function fetchResource(path) {
  return new Promise((resolve, reject) => {
    https.get(`https://www.dnd5eapi.co${path}`, (response) => {
      let data = '';
      
      // Handle HTTP errors
      if (response.statusCode !== 200) {
        reject(new Error(`HTTP Error: ${response.statusCode}`));
        return;
      }
      
      response.on('data', (chunk) => { data += chunk; });
      response.on('end', () => {
        try {
          const parsedData = JSON.parse(data);
          resolve(parsedData);
        } catch (error) {
          reject(new Error('Error parsing JSON response'));
        }
      });
    }).on('error', (error) => {
      reject(error);
    });
  });
}

// Example usage with error handling
fetchResource('/api/classes/invalid-class')
  .then(data => {
    console.log('Class details:', data);
  })
  .catch(error => {
    console.error('Failed to fetch class:', error.message);
    // Handle different types of errors appropriately
  });

  </TabItem>
  <TabItem value="python" label="Python">
python
import requests

try:
    response = requests.get('https://www.dnd5eapi.co/api/spells/not-a-real-spell')
    response.raise_for_status()  # Raise an exception for 4XX/5XX responses
    spell = response.json()
    print(f"Spell: {spell['name']}")
except requests.exceptions.HTTPError as err:
    print(f"HTTP Error: {err}")
except requests.exceptions.RequestException as err:
    print(f"Error: {err}")

  </TabItem>
  <TabItem value="curl" label="cURL (Shell)">
bash
# Handle potential errors with proper exit codes
response=$(curl -s -w "%{http_code}" https://www.dnd5eapi.co/api/races/unknown-race)
http_code=${response: -3}
body=${response:0:${#response}-3}

if [ $http_code -eq 200 ]; then
    echo "Success! Found race:"
    echo "$body" | json_pp
else
    echo "Error! HTTP Status Code: $http_code"
    echo "$body" | json_pp
    exit 1
fi

  </TabItem>
  <TabItem value="php" label="PHP">
php
<?php
function fetchDndResource($endpoint) {
    $url = "https://www.dnd5eapi.co/api/" . $endpoint;
    
    // Initialize cURL session
    $curl = curl_init($url);
    curl_setopt_array($curl, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_FAILONERROR => false, // Don't fail silently on HTTP errors
    ]);
    
    // Execute the request
    $response = curl_exec($curl);
    $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    $error = curl_error($curl);
    curl_close($curl);
    
    // Handle errors
    if ($error) {
        throw new Exception("cURL Error: " . $error);
    }
    
    if ($httpCode !== 200) {
        throw new Exception("HTTP Error: " . $httpCode);
    }
    
    // Parse JSON response
    $data = json_decode($response, true);
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception("JSON Parse Error: " . json_last_error_msg());
    }
    
    return $data;
}

// Usage example with try/catch
try {
    $data = fetchDndResource("monsters/nonexistent-monster");
    echo "Monster: " . $data['name'] . "\n";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
    // Handle the error appropriately
}
?>

  </TabItem>
  <TabItem value="java" label="Java">
java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class DndApiErrorHandling {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.dnd5eapi.co/api/races/nonexistent-race"))
                .build();
                
            HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
                
            if (response.statusCode() != 200) {
                System.out.println("HTTP Error: " + response.statusCode());
                System.out.println("Response body: " + response.body());
                return;
            }
            
            // Process successful response
            System.out.println("Success! Response: " + response.body());
            
        } catch (IOException e) {
            System.out.println("Network error: " + e.getMessage());
        } catch (InterruptedException e) {
            System.out.println("Request interrupted: " + e.getMessage());
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            System.out.println("Unexpected error: " + e.getMessage());
        }
    }
}

  </TabItem>
  <TabItem value="csharp" label="C#">
csharp
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text.Json;

class DndApiErrorHandling
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        try 
        {
            // Try to get a non-existent resource
            var response = await client.GetAsync("https://www.dnd5eapi.co/api/classes/nonexistent-class");
            
            // Check for success status code
            response.EnsureSuccessStatusCode();
            
            // Process the response if successful
            var content = await response.Content.ReadAsStringAsync();
            var data = JsonSerializer.Deserialize<JsonElement>(content);
            Console.WriteLine($"Class: {data.GetProperty("name").GetString()}");
        }
        catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
        {
            Console.WriteLine("Resource not found (404)");
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"HTTP error: {ex.StatusCode}");
            Console.WriteLine(ex.Message);
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSON parsing error: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Unexpected error: {ex.Message}");
        }
    }
}

  </TabItem>
  <TabItem value="ruby" label="Ruby">
ruby
require 'net/http'
require 'json'

def fetch_dnd_resource(endpoint)
  uri = URI("https://www.dnd5eapi.co/api/#{endpoint}")
  
  begin
    response = Net::HTTP.get_response(uri)
    
    # Check for HTTP errors
    case response
    when Net::HTTPSuccess
      return JSON.parse(response.body)
    when Net::HTTPNotFound
      raise "Resource not found (404)"
    else
      raise "HTTP Error: #{response.code} #{response.message}"
    end
  rescue JSON::ParserError
    raise "Invalid JSON response"
  rescue StandardError => e
    raise "Network or other error: #{e.message}"
  end
end

# Example usage with error handling
begin
  spell = fetch_dnd_resource('spells/nonexistent-spell')
  puts "Spell: #{spell['name']}"
rescue StandardError => e
  puts "Error: #{e.message}"
  # Handle the error appropriately
end

  </TabItem>
  <TabItem value="go" label="Go">
go
package main

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

func fetchDndResource(endpoint string) ([]byte, error) {
	url := fmt.Sprintf("https://www.dnd5eapi.co/api/%s", endpoint)
	
	response, err := http.Get(url)
	if err != nil {
		return nil, fmt.Errorf("request error: %v", err)
	}
	defer response.Body.Close()
	
	// Check HTTP status code
	if response.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error: %d %s", response.StatusCode, response.Status)
	}
	
	// Read the response body
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return nil, fmt.Errorf("error reading response: %v", err)
	}
	
	return body, nil
}

func main() {
	// Try to fetch a non-existent resource
	body, err := fetchDndResource("spells/nonexistent-spell")
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	
	// Parse the JSON response
	var spell map[string]interface{}
	if err := json.Unmarshal(body, &spell); err != nil {
		fmt.Printf("Error parsing JSON: %v\n", err)
		return
	}
	
	fmt.Printf("Spell: %v\n", spell["name"])
}

  </TabItem>
</Tabs>

## GraphQL Examples

The D&D 5e SRD API also supports GraphQL queries at `https://www.dnd5eapi.co/graphql`. Here's how to use GraphQL in different languages:

<Tabs groupId="programming-language">
  <TabItem value="javascript-browser" label="JavaScript">
javascript
// Using fetch with GraphQL
const query = `
{
  spells(filter: {level: {eq: 3}, school: {index: {eq: "evocation"}}}) {
    name
    desc
    higher_level
    range
    components
    material
    ritual
    duration
    concentration
    casting_time
    level
    attack_type
    damage {
      damage_type {
        name
      }
      damage_at_slot_level {
        level
        damage
      }
    }
  }
}`;

fetch('https://www.dnd5eapi.co/graphql', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ query }),
})
  .then(response => response.json())
  .then(data => {
    console.log('GraphQL response:', data);
    console.log('Spells found:', data.data.spells.length);
    data.data.spells.forEach(spell => {
      console.log(`- ${spell.name} (${spell.casting_time})`);
    });
  })
  .catch(error => {
    console.error('Error:', error);
  });

  </TabItem>
  <TabItem value="python" label="Python">
python
import requests

query = """
{
  classes {
    name
    hit_die
    proficiencies {
      name
    }
    spellcasting {
      spellcasting_ability {
        name
      }
    }
  }
}
"""

response = requests.post(
    'https://www.dnd5eapi.co/graphql',
    json={'query': query}
)

data = response.json()
classes = data['data']['classes']

print(f"Found {len(classes)} classes:")
for dnd_class in classes:
    print(f"- {dnd_class['name']} (Hit Die: d{dnd_class['hit_die']})")
    
    if dnd_class['spellcasting']:
        ability = dnd_class['spellcasting']['spellcasting_ability']['name']
        print(f"  Spellcasting Ability: {ability}")

  </TabItem>
  <TabItem value="curl" label="cURL">
bash
# Query for monsters with challenge rating 5
curl -s -X POST \
  -H "Content-Type: application/json" \
  -d '{"query": "{ monsters(filter: {challenge_rating: {eq: 5}}) { name size type alignment hit_points armor_class { value } } }"}' \
  https://www.dnd5eapi.co/graphql | json_pp

  </TabItem>
</Tabs>

## Additional Resources

- [GitHub Repository](https://github.com/5e-bits/5e-srd-api)
- [Discord Community](https://discord.gg/TQuYTv7)
- [GraphQL Documentation](/docs/graphql)
- [API Reference](/docs/reference) 

[fergcb]

@paulchrisluke In order to open a PR you don't need to request access or anything, you just need to fork the relevant repo (in this case docs), make your changes in your fork, and then open a PR targeting the upstream repo.

However; idk what @bagelbits and @ecshreve think, but I think we've already addressed this issue by including snippets in the same style shown above in our new docs.

Maybe refactoring what you've into a more instructional tutorial for the Tutorials section of the docs would be beneficial though?

[paulchrisluke]

@paulchrisluke In order to open a PR you don't need to request access or anything, you just need to fork the relevant repo (in this case docs), make your changes in your fork, and then open a PR targeting the upstream repo

Got it.

Maybe refactoring what you've into a more instructional tutorial for the Tutorials section of the docs would be beneficial though?

I'll take a crack at this this weekend. Thank you!