# List Domains by Publication URL

POST /api/v1/qllm/domain/by-url/
Content-Type: application/json

This endpoint accepts a POST request with a JSON body containing a 'url' parameter (the publication's custom URL) and returns a paginated list of domains filtered based on the owner extracted from that publication. In addition, query parameters such as 'id', 'tag', 'recommended', 'n', search, and additional filters can be used for further filtering or random selection.

Reference: https://docs.aisquare.studio/api-reference/ai-square-studio-api/qllm/domain-by-url-create

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: AISquare Studio API
  version: 1.0.0
paths:
  /api/v1/qllm/domain/by-url/:
    post:
      operationId: domain-by-url-create
      summary: List Domains by Publication URL
      description: >-
        This endpoint accepts a POST request with a JSON body containing a 'url'
        parameter (the publication's custom URL) and returns a paginated list of
        domains filtered based on the owner extracted from that publication. In
        addition, query parameters such as 'id', 'tag', 'recommended', 'n',
        search, and additional filters can be used for further filtering or
        random selection.
      tags:
        - subpackage_qllm
      parameters:
        - name: category
          in: query
          description: Filter domains by category name.
          required: false
          schema:
            type: string
        - name: id
          in: query
          description: Filter by domain UID.
          required: false
          schema:
            type: string
        - name: most_popular
          in: query
          description: >-
            Sort domains by popularity (number of users). Mutually exclusive
            with other sorting options.
          required: false
          schema:
            type: string
        - name: most_recent
          in: query
          description: >-
            Sort domains by creation date (most recent first). Mutually
            exclusive with other sorting options.
          required: false
          schema:
            type: string
        - name: 'n'
          in: query
          description: Limit the number of random domains returned.
          required: false
          schema:
            type: integer
        - name: recently_viewed
          in: query
          description: >-
            Sort domains by last update date (most recently updated first).
            Mutually exclusive with other sorting options.
          required: false
          schema:
            type: string
        - name: recommended
          in: query
          description: Flag to retrieve recommended domains.
          required: false
          schema:
            type: string
        - name: saved
          in: query
          description: Filter to show only saved domains (requires authentication).
          required: false
          schema:
            type: string
        - name: search
          in: query
          description: >-
            Search across domain name, summary, description, and creator
            usernames.
          required: false
          schema:
            type: string
        - name: subcategory
          in: query
          description: Filter domains by subcategory name.
          required: false
          schema:
            type: string
        - name: tag
          in: query
          description: Filter domains by a specific tag.
          required: false
          schema:
            type: string
      responses:
        '200':
          description: >-
            A paginated list of domains filtered by the Publication owner and
            additional filters.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainInfo'
        '400':
          description: Invalid input or missing 'url' parameter.
          content:
            application/json:
              schema:
                description: Any type
        '403':
          description: Permission denied to view the domain.
          content:
            application/json:
              schema:
                description: Any type
        '404':
          description: No domains found matching the criteria for this owner.
          content:
            application/json:
              schema:
                description: Any type
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                url:
                  type: string
                  description: Publication's custom URL.
              required:
                - url
components:
  schemas:
    UserSimple:
      type: object
      properties:
        id:
          type: integer
        username:
          type: string
          description: >-
            Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
        email:
          type: string
          format: email
        full_name:
          type: string
        first_time_login:
          type: boolean
          description: Check if this is the user's first login.
        theme:
          type:
            - string
            - 'null'
        is_superuser:
          type: boolean
          description: >-
            Designates that this user has all permissions without explicitly
            assigning them.
        is_staff:
          type: boolean
          description: Designates whether the user can log into this admin site.
        is_active:
          type: boolean
          description: >-
            Designates whether this user should be treated as active. Unselect
            this instead of deleting accounts.
        is_verified:
          type: boolean
        profile_picture:
          type: string
          format: uri
          description: |-
            Convert ImageFieldFile to URL string for JSON serialization.

            Args:
                obj: The model instance being serialized (typically IAMUser)

            Returns:
                str | None: The URL of the profile picture, or None if not available
      required:
        - id
        - username
        - email
        - first_time_login
        - profile_picture
      description: >-
        Mixin to handle profile_picture serialization for WebSocket
        compatibility.


        This mixin adds a SerializerMethodField for profile_picture that
        converts

        ImageFieldFile objects to URL strings, making them JSON serializable for

        WebSocket consumers.


        The mixin intelligently handles profile pictures from IAMUserDetail by:

        1. Accessing the related `details` queryset on the IAMUser model

        2. Extracting the ImageFieldFile from the first detail record

        3. Converting it to a URL string for JSON serialization


        Usage:
            ```python
            class MyUserSerializer(ProfilePictureMixin, serializers.ModelSerializer):
                class Meta:
                    model = User
                    fields = ['id', 'username', 'profile_picture', ...]
            ```

        Note:
            - This mixin expects the model to have a `details` related manager
            - The related detail should have a `profile_picture` ImageField
            - Returns None if no profile picture is found or an error occurs
      title: UserSimple
    GlobalVisibilityEnum:
      type: string
      enum:
        - public
        - private
        - team
        - org
      description: |-
        * `public` - Public
        * `private` - Private
        * `team` - Team
        * `org` - Organization
      title: GlobalVisibilityEnum
    GlobalCreationStatusEnum:
      type: string
      enum:
        - not_started
        - in_progress
        - completed
        - failed
      description: |-
        * `not_started` - Not Started
        * `in_progress` - In Progress
        * `completed` - Completed
        * `failed` - Failed
      title: GlobalCreationStatusEnum
    DomainInfo:
      type: object
      properties:
        id:
          type: string
          format: uuid
        domain_id:
          type: integer
        name:
          type: string
        theme:
          type: string
        summary:
          type:
            - string
            - 'null'
        description:
          type:
            - string
            - 'null'
        logo:
          type:
            - string
            - 'null'
          format: uri
          description: Logo image for the domain (copied from experience)
        cover:
          type:
            - string
            - 'null'
          format: uri
          description: Cover image for the domain (copied from experience)
        tags:
          type: array
          items:
            type: string
        created_by:
          $ref: '#/components/schemas/UserSimple'
        category:
          type:
            - string
            - 'null'
        subcategory:
          type:
            - string
            - 'null'
        focus_area:
          type:
            - string
            - 'null'
        visibility:
          $ref: '#/components/schemas/GlobalVisibilityEnum'
        is_draft:
          type: boolean
        co_creators:
          type: array
          items:
            $ref: '#/components/schemas/UserSimple'
        creation_status:
          $ref: '#/components/schemas/GlobalCreationStatusEnum'
        saved:
          type: boolean
        metrics:
          type: string
        workspace_id:
          type: integer
        publication:
          type:
            - object
            - 'null'
          additionalProperties:
            description: Any type
      required:
        - id
        - domain_id
        - tags
        - created_by
        - category
        - subcategory
        - co_creators
        - saved
        - metrics
        - workspace_id
        - publication
      title: DomainInfo

```

## SDK Code Examples

```python
import requests

url = "https://api.example.com/api/v1/qllm/domain/by-url/"

payload = { "url": "https://examplepublication.com/custom-article-123" }
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.example.com/api/v1/qllm/domain/by-url/';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"url":"https://examplepublication.com/custom-article-123"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://api.example.com/api/v1/qllm/domain/by-url/"

	payload := strings.NewReader("{\n  \"url\": \"https://examplepublication.com/custom-article-123\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

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

url = URI("https://api.example.com/api/v1/qllm/domain/by-url/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"url\": \"https://examplepublication.com/custom-article-123\"\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/v1/qllm/domain/by-url/")
  .header("Content-Type", "application/json")
  .body("{\n  \"url\": \"https://examplepublication.com/custom-article-123\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/v1/qllm/domain/by-url/', [
  'body' => '{
  "url": "https://examplepublication.com/custom-article-123"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/api/v1/qllm/domain/by-url/");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"url\": \"https://examplepublication.com/custom-article-123\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["url": "https://examplepublication.com/custom-article-123"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/v1/qllm/domain/by-url/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```