> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wistx.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Search Code Examples

> Search infrastructure code examples from curated repositories

> Search infrastructure code examples from curated repositories. Supports filtering by code type, cloud provider, services, quality score, and compliance standards.

## Endpoint

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://api.wistx.ai/v1/code-examples/search \
    --header 'Authorization: Bearer YOUR_API_KEY' \
    --header 'Content-Type: application/json' \
    --data '{
      "query": "RDS database with encryption",
      "code_types": ["terraform", "kubernetes"],
      "cloud_provider": "aws",
      "services": ["rds"],
      "min_quality_score": 70,
      "compliance_standard": "PCI-DSS",
      "limit": 10
    }'
  ```

  ```python Python theme={null}
  import requests

  api_key = "YOUR_API_KEY"
  url = "https://api.wistx.ai/v1/code-examples/search"

  response = requests.post(
      url,
      headers={
          "Authorization": f"Bearer {api_key}",
          "Content-Type": "application/json"
      },
      json={
          "query": "RDS database with encryption",
          "code_types": ["terraform", "kubernetes"],
          "cloud_provider": "aws",
          "services": ["rds"],
          "min_quality_score": 70,
          "compliance_standard": "PCI-DSS",
          "limit": 10
      }
  )

  data = response.json()
  print(data)
  ```

  ```javascript JavaScript theme={null}
  const apiKey = "YOUR_API_KEY";
  const url = "https://api.wistx.ai/v1/code-examples/search";

  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      query: "RDS database with encryption",
      code_types: ["terraform", "kubernetes"],
      cloud_provider: "aws",
      services: ["rds"],
      min_quality_score: 70,
      compliance_standard: "PCI-DSS",
      limit: 10
    })
  });

  const data = await response.json();
  console.log(data);
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "net/http"
  )

  func main() {
      apiKey := "YOUR_API_KEY"
      url := "https://api.wistx.ai/v1/code-examples/search"

      payload := map[string]interface{}{
          "query":              "RDS database with encryption",
          "code_types":         []string{"terraform", "kubernetes"},
          "cloud_provider":     "aws",
          "services":           []string{"rds"},
          "min_quality_score":  70,
          "compliance_standard": "PCI-DSS",
          "limit":              10,
      }

      jsonData, _ := json.Marshal(payload)
      req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
      req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()
  }
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'

  uri = URI('https://api.wistx.ai/v1/code-examples/search')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri.path)
  request['Authorization'] = 'Bearer YOUR_API_KEY'
  request['Content-Type'] = 'application/json'
  request.body = {
    query: "RDS database with encryption",
    code_types: ["terraform", "kubernetes"],
    cloud_provider: "aws",
    services: ["rds"],
    min_quality_score: 70,
    compliance_standard: "PCI-DSS",
    limit: 10
  }.to_json

  response = http.request(request)
  puts response.body
  ```

  ```php PHP theme={null}
  <?php

  $url = "https://api.wistx.ai/v1/code-examples/search";
  $data = [
      "query" => "RDS database with encryption",
      "code_types" => ["terraform", "kubernetes"],
      "cloud_provider" => "aws",
      "services" => ["rds"],
      "min_quality_score" => 70,
      "compliance_standard" => "PCI-DSS",
      "limit" => 10
  ];

  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      "Authorization: Bearer YOUR_API_KEY",
      "Content-Type: application/json"
  ]);

  $response = curl_exec($ch);
  curl_close($ch);
  echo $response;
  ```

  ```java Java theme={null}
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.URI;
  import java.nio.charset.StandardCharsets;

  HttpClient client = HttpClient.newHttpClient();
  String json = "{\"query\":\"RDS database with encryption\",\"code_types\":[\"terraform\",\"kubernetes\"],\"cloud_provider\":\"aws\",\"services\":[\"rds\"],\"min_quality_score\":70,\"compliance_standard\":\"PCI-DSS\",\"limit\":10}";

  HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.wistx.ai/v1/code-examples/search"))
      .header("Authorization", "Bearer YOUR_API_KEY")
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString(json))
      .build();

  HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  System.out.println(response.body());
  ```
</CodeGroup>

## Request Parameters

<ParamField body="query" type="string" required>
  Search query in natural language (3-1,000 characters). Examples:

  * "RDS database with encryption"
  * "Kubernetes deployment with autoscaling"
  * "Terraform module for VPC"
  * "Docker compose with health checks"
</ParamField>

<ParamField body="code_types" type="string[]">
  Filter by code types. Supported types:

  **Infrastructure as Code:**

  * `terraform`, `opentofu`, `pulumi`, `ansible`, `cloudformation`, `bicep`, `arm`, `cdk`, `cdk8s`

  **Container & Orchestration:**

  * `kubernetes`, `docker`, `helm`

  **CI/CD:**

  * `github_actions`, `gitlab_ci`, `jenkins`, `circleci`, `argo_workflows`, `tekton`

  **Continuous Deployment:**

  * `argocd`, `flux`, `spinnaker`

  **Monitoring & Observability:**

  * `prometheus`, `grafana`, `datadog`, `opentelemetry`

  **Platform Engineering:**

  * `crossplane`, `karpenter`, `backstage`

  **Serverless:**

  * `sam`, `serverless`

  **Automation:**

  * `bash`, `powershell`
</ParamField>

<ParamField body="cloud_provider" type="string">
  Filter by cloud provider: `aws`, `gcp`, `azure`, `oracle`, `alibaba`
</ParamField>

<ParamField body="services" type="string[]">
  Filter by cloud services (e.g., `["rds", "s3", "ec2"]`). Examples:

  * AWS: `rds`, `s3`, `ec2`, `lambda`, `eks`, `vpc`, `iam`
  * GCP: `gce`, `gke`, `cloudsql`, `cloudstorage`, `cloudfunctions`
  * Azure: `aks`, `sql`, `storage`, `functions`, `vnet`
</ParamField>

<ParamField body="min_quality_score" type="integer">
  Minimum quality score (0-100). Filters examples by quality metrics including:

  * Code completeness
  * Best practices adherence
  * Documentation quality
  * Repository popularity (stars)
</ParamField>

<ParamField body="compliance_standard" type="string">
  Filter by compliance standard. Returns only examples that implement controls for the specified standard:

  * `PCI-DSS` - Payment Card Industry Data Security Standard
  * `HIPAA` - Health Insurance Portability and Accountability Act
  * `SOC2` - System and Organization Controls 2
  * `CIS` - Center for Internet Security Benchmarks
  * `NIST-800-53` - NIST Cybersecurity Framework
  * `ISO-27001` - ISO Information Security Management
</ParamField>

<ParamField body="limit" type="integer" default="10">
  Maximum number of results (1-100)
</ParamField>

## Response Example

<ResponseExample>
  ```json 200 Success theme={null}
  {
    "data": {
      "examples": [
        {
          "example_id": "ex_abc123",
          "title": "Encrypted RDS Instance with Backup",
          "description": "Terraform configuration for an encrypted RDS PostgreSQL instance with automated backups",
          "contextual_description": "This Terraform code creates a production-ready RDS PostgreSQL database with encryption at rest, automated backups, and multi-AZ deployment. It demonstrates best practices for database security and compliance with PCI-DSS requirements.",
          "code_type": "terraform",
          "cloud_provider": "aws",
          "services": ["rds"],
          "resources": ["aws_db_instance", "aws_db_subnet_group", "aws_db_parameter_group"],
          "code": "resource \"aws_db_instance\" \"main\" {\n  identifier = \"prod-postgres\"\n  engine = \"postgres\"\n  engine_version = \"15.4\"\n  instance_class = \"db.t3.medium\"\n  allocated_storage = 100\n  storage_encrypted = true\n  kms_key_id = aws_kms_key.rds.arn\n  db_name = \"mydb\"\n  username = \"admin\"\n  password = var.db_password\n  vpc_security_group_ids = [aws_security_group.rds.id]\n  db_subnet_group_name = aws_db_subnet_group.main.name\n  backup_retention_period = 7\n  backup_window = \"03:00-04:00\"\n  maintenance_window = \"mon:04:00-mon:05:00\"\n  multi_az = true\n  deletion_protection = true\n  enabled_cloudwatch_logs_exports = [\"postgresql\", \"upgrade\"]\n  performance_insights_enabled = true\n  tags = {\n    Environment = \"production\"\n    Compliance = \"PCI-DSS\"\n  }\n}",
          "github_url": "https://github.com/terraform-aws-modules/terraform-aws-rds",
          "file_path": "examples/postgres/main.tf",
          "stars": 1250,
          "quality_score": 85,
          "best_practices": [
            "Encryption at rest enabled",
            "Automated backups configured",
            "Multi-AZ deployment",
            "CloudWatch logging enabled",
            "Performance Insights enabled"
          ],
          "hybrid_score": 0.92,
          "vector_score": 0.89,
          "bm25_score": 0.95,
          "compliance_analysis": {
            "applicable_standards": ["PCI-DSS", "HIPAA", "SOC2"],
            "compliance_score": {
              "PCI-DSS": 0.95,
              "HIPAA": 0.88,
              "SOC2": 0.90
            }
          },
          "cost_analysis": {
            "estimated_monthly": 125.50,
            "estimated_annual": 1506.00
          }
        }
      ],
      "total": 1,
      "query": "RDS database with encryption"
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123,
      "query_time_ms": 245
    }
  }
  ```

  ```json 400 Bad Request theme={null}
  {
    "error": {
      "code": "VALIDATION_ERROR",
      "message": "Invalid request parameters",
      "details": "query must be at least 3 characters"
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123
    }
  }
  ```

  ```json 401 Unauthorized theme={null}
  {
    "error": {
      "code": "UNAUTHORIZED",
      "message": "Invalid or expired token"
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123
    }
  }
  ```

  ```json 429 Too Many Requests theme={null}
  {
    "error": {
      "code": "QUOTA_EXCEEDED",
      "message": "Query quota exceeded",
      "details": {
        "limit_type": "queries_per_month",
        "current": 1000,
        "limit": 1000
      }
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123
    }
  }
  ```

  ```json 500 Internal Server Error theme={null}
  {
    "error": {
      "code": "INTERNAL_ERROR",
      "message": "Failed to search code examples"
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123
    }
  }
  ```

  ```json 503 Service Unavailable theme={null}
  {
    "error": {
      "code": "DATABASE_ERROR",
      "message": "Database connection failed"
    },
    "metadata": {
      "request_id": "req_123",
      "timestamp": 1234567890.123
    }
  }
  ```
</ResponseExample>

## Response Fields

### Code Example Object

<Field name="example_id" type="string">
  Unique identifier for the code example
</Field>

<Field name="title" type="string">
  Title of the code example
</Field>

<Field name="description" type="string">
  Brief description of what the code does
</Field>

<Field name="contextual_description" type="string">
  AI-generated contextual description that explains the infrastructure, use cases, and best practices demonstrated
</Field>

<Field name="code_type" type="string">
  Type of code (terraform, kubernetes, docker, etc.)
</Field>

<Field name="cloud_provider" type="string">
  Cloud provider (aws, gcp, azure)
</Field>

<Field name="services" type="string[]">
  List of cloud services used in the code
</Field>

<Field name="resources" type="string[]">
  List of resource types managed by the code
</Field>

<Field name="code" type="string">
  Full code content
</Field>

<Field name="github_url" type="string">
  URL to the GitHub repository containing this code
</Field>

<Field name="file_path" type="string">
  Path to the file within the repository
</Field>

<Field name="stars" type="integer">
  Number of GitHub stars for the repository
</Field>

<Field name="quality_score" type="integer">
  Quality score (0-100) based on code completeness, best practices, and documentation
</Field>

<Field name="best_practices" type="string[]">
  List of best practices identified in the code
</Field>

<Field name="hybrid_score" type="float">
  Combined relevance score from vector and BM25 search (0.0-1.0)
</Field>

<Field name="vector_score" type="float">
  Vector similarity score (0.0-1.0)
</Field>

<Field name="bm25_score" type="float">
  BM25 keyword matching score (0.0-1.0)
</Field>

<Field name="compliance_analysis" type="object">
  Compliance analysis results:

  * `applicable_standards`: List of compliance standards applicable to this code
  * `compliance_score`: Object mapping standard names to compliance scores (0.0-1.0)
</Field>

<Field name="cost_analysis" type="object">
  Estimated cost analysis:

  * `estimated_monthly`: Estimated monthly cost in USD
  * `estimated_annual`: Estimated annual cost in USD
</Field>

## Use Cases

### Find Production-Ready Examples

Search for code examples that demonstrate production-ready patterns:

```json theme={null}
{
  "query": "Kubernetes deployment with autoscaling and health checks",
  "min_quality_score": 80,
  "limit": 5
}
```

### Compliance-Focused Search

Find code examples that implement specific compliance requirements:

```json theme={null}
{
  "query": "encrypted database with audit logging",
  "compliance_standard": "HIPAA",
  "code_types": ["terraform"],
  "cloud_provider": "aws"
}
```

### Multi-Tool Examples

Search across multiple infrastructure tools:

```json theme={null}
{
  "query": "CI/CD pipeline with infrastructure deployment",
  "code_types": ["github_actions", "terraform", "kubernetes"],
  "limit": 10
}
```

### Cost-Optimized Examples

Find examples that demonstrate cost optimization:

```json theme={null}
{
  "query": "serverless architecture with cost optimization",
  "code_types": ["terraform", "sam", "serverless"],
  "cloud_provider": "aws"
}
```

## Search Features

### Hybrid Search

The endpoint uses a hybrid search approach combining:

* **Vector Search**: Semantic understanding of your query using embeddings
* **BM25 Search**: Keyword-based matching for precise term matching
* **Reranking**: Optional reranking for improved relevance

### Quality Filtering

Examples are scored based on:

* Code completeness and correctness
* Best practices adherence
* Documentation quality
* Repository popularity (GitHub stars)
* Production readiness indicators

### Compliance Mapping

When filtering by `compliance_standard`, the search:

1. Identifies examples that implement relevant compliance controls
2. Returns only examples with verified compliance mappings
3. Includes compliance scores for applicable standards

## Rate Limits

* **Professional**: 2,000 queries/month
* **Team**: 10,000 queries/month
* **Enterprise**: Unlimited queries/month

## Data Sources

Code examples are collected from:

* **Curated GitHub Repositories**: High-quality repositories with 200+ stars
* **Official Documentation**: Examples from official cloud provider documentation
* **Community Best Practices**: Production-tested patterns from the community

All examples are:

* ✅ Production-ready and tested
* ✅ Enriched with compliance analysis
* ✅ Analyzed for cost implications
* ✅ Tagged with best practices
* ✅ Contextually described for better search

## Related Endpoints

* [Search Codebase](/api-reference/search/codebase) - Search your own indexed repositories
* [Compliance Requirements](/api-reference/compliance) - Get compliance requirements for resources
* [Pricing Calculation](/api-reference/pricing/calculate) - Calculate infrastructure costs


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.